this.me 2.8.1 → 2.8.3

package/README.md

@@ -1,77 +1,66 @@
-<img src="https://suign.github.io/this.me/neurons_logo.png" alt="SVG Image" width="123" height="123" style="width123px; height:123px;">
-
 # This.Me  
+<img src="./cleak_me-removebg.png" alt="SVG Image" style="width:89px;">
+<img src="./this.me.png" alt="SVG Image" style="width:89px;">
 
-**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. 
+**This.Me** defines a digital identity through a cryptographic lens. Each user is equipped with a unique **'Me'** identity, secured by public-private key cryptography, enabling robust autonomous identity verification and transactional security.
 
-## Getting Started: 
-```bash
-npm i -g this.me
-```
+**This.Me** incorporates hashing for unimpeachable data integrity and digital signatures for undeniable authenticity. Users gain unparalleled control over their digital footprint, marking a shift towards a user-centric model of data management.
+
+In essence, **This.Me** grants users a self-sovereign digital identity, fully within their control and independent from external entities.
+
+### CLI Usage:
+Install globally to use `this.me` as a CLI tool:
 
-### Require it:
 ```js
-const me = require('this.me');
+npm install -g this.me
 ```
 
-### Usage Example:
-Use it like this:
+Then, interact with `this.me` directly from your command line.
+
+
+### Usage in Node.js:
+
+## Installation
+
+```bash
+npm install this.me
+```
 
 ```js
 const ThisMe = require('this.me');
+// Create a new user identity
 const user = new ThisMe('John', 'Doe', '1990-01-01', 'mypassword123', '1234');
+// Retrieve the user's identity object
 const identityObject = user.getIdentityObject();
-// identityObject can now be passed to Cleaker for hashing
 ```
 
-## Understanding .ME
+## Core Principles
+
+- The `Me` class encapsulates personal information:
+
+name, 
+last name, 
+birthday,
+password, 
+PIN 
+
+This serves as the identity representation in our system.
 
-##### Structure of this.me Package:
+The `all.this` collection of packages, along with the proposed `cleaker` functionality, is an approach to create a modular system where each module (like `this.text`, `this.video`, `this.img`, etc.) (all.this family) represents a distinct data structure or class. These modules, when combined with `cleaker`, generate unique **public and private key pairs**, essentially giving each instance its cryptographic identity.
 
-**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.
+### Hashing and Digital Signatures
 
+**This.Me** leverages hashing to protect data integrity, with each transaction generating a unique, tamper-proof hash. Digital signatures, created using private keys, provide a layer of authenticity and non-repudiation, linking data unmistakably to its owner.
+
+## Contextual Environment
+
+**This.Me** adapts to various environments, enabling `.me` objects to function both locally and within a network. A `.me` object authenticated on a network accesses data beyond the local scope, while unauthenticated instances are confined to local data. This dual functionality ensures seamless interoperability and heightened security.
+
+## Setting up your Context. 	👋🏻👋🏼👋🏽👋🏾👋🏿
 
-# 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.
-   - 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 includes 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.
-
-### 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.
+`.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. 
+

package/index.js

@@ -0,0 +1,15 @@
+//index.js
+/**
+ * @module This.Me
+ * @description
+ * This.Me adapts to various environments, enabling `.me` objects to function both locally and within a network. 
+ *  A `.me` object authenticated on a network accesses data beyond the local scope, 
+ *  while unauthenticated instances are confined to local data.
+ *  This dual functionality ensures seamless interoperability and heightened security.
+ *  Command Definitions and Interactive Shell.*/
+
+// index.js in the `this.me` package
+export { default } from './src/me.js';
+console.log('this.me loaded successfully.');
+// this.me/index.js
+export { shell } from './src/cli/shell.js';

package/jsdoc.json

@@ -1,10 +1,10 @@
 {
   "source": {
-    "include": ["./src", "./index.js", "./src/cli"]
+    "include": ["./src", "./index.js", "./src/cli", "./src/cli/commands.js", "./src/cli/shell.js"]
   },
   "opts": {
     "destination": "./docs",
-    "template": "../neurons.me/src/assets/better-docs",
+    "template": "../../../../../Sandbox/dev_tools/assets/better-docs",
     "readme": "./README.md"
   },
   "templates": {
@@ -24,18 +24,26 @@
       "hideGenerator": false,
       "navLinks": [
         {
-          "label": "all.This @Packages",
+          "label": "All.This",
           "href": "https://suign.github.io/all.this/"
-        },
-        {
-          "label": "Github",
-          "href": "https://github.com/suiGn/neurons.me"
-        },
-        {
-          "label": "App",
-          "href": "https://neurons.me"
-        }
+      },
+      {
+        "label": "@Source",
+        "href": "https://suign.github.io/"
+    },
+          {
+              "label": "Github",
+              "href": "https://github.com/suiGn/cleaker"
+          },
+          {
+              "label": "Cleaker.me",
+              "href": "https://cleaker.me"
+          },
+          {
+            "label": "What is all.this?",
+              "href": "https://www.neurons.me/this"
+          }
       ]
-    }
+        }
   }
 }

package/nino.js

@@ -0,0 +1,2 @@
+
+

package/package.json

@@ -1,10 +1,7 @@
 {
   "name": "this.me",
-  "version": "2.8.1",
-  "description": "User-Centric OS.",
-  "bin": {
-    ".me": "./src/cli/main.js"
-  },
+  "version": "2.8.3",
+  "description": "User-Centric.",
   "type": "module",
   "main": "index.js",
   "scripts": {
@@ -30,7 +27,6 @@
   "repoType": "NPM Package",
   "dependencies": {
     "commander": "^11.1.0",
-    "inquirer": "^9.2.12",
-    "taffydb": "^2.7.3"
+    "inquirer": "^9.2.12"
   }
 }

package/src/cli/CLI.md

@@ -0,0 +1,20 @@
+Main CLI Application (main.ts)
+
+This is the entry point for your CLI application.
+It displays a welcome message and user information (host session and path).
+It imports the CLI commands (commands.ts) and the interactive shell (shell.ts).
+CLI Commands (commands.ts)
+
+This part defines the CLI commands and options using the commander package.
+Currently, it defines the commands: 'View Existing Profiles,' 'Create New Profile,' and 'Exit.'
+Interactive Shell (shell.ts)
+
+The interactive shell provides a user-friendly interface for interacting with the CLI.
+selectMe: Presents a list of actions for the user to choose from.
+createMe: Prompts the user for details to create a new Me profile.
+writeMe: Writes the Me profile to the filesystem.
+listMeProfiles: Lists all existing Me profiles.
+selectProfile: Prompts the user to select a Me profile or go back to the main menu.
+
+
+

package/src/cli/ascii_art/welcome.js

@@ -18,4 +18,4 @@ Welcome to .me.
 `);
 }
 
-export default printWelcome;
+export default printWelcome;

package/src/cli/commands.js

@@ -0,0 +1,17 @@
+// src/cli/commands.js
+
+import { Command } from 'commander';
+const program = new Command();
+
+program
+    .option('-o, --options', 'View options and commands.');
+
+program
+    .command('user <username> <pin>')
+    .description('Authenticate and start a .me session.')
+    .action((username, pin) => {
+        console.log(`Attempting to authenticate user: ${username}`);
+        // Authentication logic here
+    });
+
+export default program;

package/src/cli/main.js

@@ -1,193 +1,45 @@
 #!/usr/bin/env node
 import os from 'os';
-import Me from '../me.js';
-import { Command } from 'commander';
-const program = new Command();
-import inquirer from 'inquirer';
-import fs from 'fs';
-import path from 'path';
+/** Welcome. */
 import printWelcome from './ascii_art/welcome.js';
-import crypto from 'crypto';
+printWelcome();
+console.log(`Host_Session@ ${os.userInfo().username}`);
+console.log(`v.path@ ${os.homedir()}/.me`);
 /**
  * @module CLI
  * @description
- * .Me Command Line Interface Functionalities.
+ * .Me - Command Line Interface.
  *  The CLI application's code structure is categorized into two main parts:
  *  Command Definitions and Interactive Shell.*/
-
-/***Command Definitions.*/
-/**
- * The 'program' variable is an instance of 'Command' from the commander package. 
- * It's utilized to define commands and options for the CLI application.*/
-program
-    .command('user <username> <pin>')
-    .description('Authenticate and start a .me session.')
-    .action((username, pin) => {
-        console.log(`Attempting to authenticate user: ${username}`);
-        // Authentication logic here
-    });
-
-program
-    .option('-o, --options', 'View options and commands');
-
-/***Welcome message.*/
-function welcomeToMe() {
-    printWelcome();
-    console.log(`Host_Session@ ${os.userInfo().username}`);
-    console.log(`v.path@ ${os.homedir()}/.me`);
-}
-
-/**
- * Prompts the user to select an action and returns their choice.
- * @returns {Promise<string>} The user's choice.
+ 
+/***
+ * Command Definitions:
+ * Leverages the `commander` package to define the CLI commands and options. 
+ **/
+import program from './commands.js';
+/***Interactive Shell:
+ * Leverages the `inquirer` package to provide an interactive shell experience with prompts.
+ * The `main` function orchestrates the CLI interactions.
  */
-async function getUserChoice() {
-  const choices = ['View Existing Profiles', 'Create New Profile', 'Exit'];
-  const answer = await inquirer.prompt([{
-      type: 'list',
-      name: 'action',
-      message: 'What would you like to do?',
-      choices: choices
-  }]);
-  return answer.action;
-}
-
-/**
-* Prompts the user for details to create a new profile.
-* @returns {Promise<Me>} The new Me object with user details.
-*/
-async function getNewProfileDetails() {
-  const questions = [
-      {
-          type: 'input',
-          name: 'name',
-          message: 'What is your first name?',
-          // Add validation as needed
-      },
-      {
-          type: 'input',
-          name: 'lastname',
-          message: 'What is your last name?',
-          // Add validation as needed
-      },
-      {
-        type: 'input',
-        name: 'birthday',
-        message: 'What is your birthday? (YYYY-MM-DD)',
-        validate: function(value) {
-            const pass = value.match(
-                /^\d{4}-\d{2}-\d{2}$/
-            );
-            if (pass) {
-                return true;
-            }
-            return 'Please enter a valid date (YYYY-MM-DD)';
-        }
-      },
-      {
-          type: 'password',
-          name: 'password',
-          message: 'Choose a password:',
-          // Add validation as needed
-      },
-      {
-          type: 'input',
-          name: 'pin',
-          message: 'Choose a PIN:',
-          // Add validation as needed
-      },
-      // ... Add more questions as needed
-  ];
-  const userDetails = await inquirer.prompt(questions);
-  return new Me(
-      userDetails.name, 
-      userDetails.lastname, 
-      userDetails.birthday,
-      userDetails.password, 
-      userDetails.pin
-  );
-}
-
-/**
-* Writes the .me object to the filesystem.
-* @param {Me} meProfile - The Me object to be saved.
-*/
-function writeMeObjectToFile(meProfile) {
-  const meDirectory = path.join(os.homedir(), '.me');
-  if (!fs.existsSync(meDirectory)) {
-      fs.mkdirSync(meDirectory, { recursive: true });
-  }
-
-  const filePath = path.join(meDirectory, `${meProfile.name}.me`);
-  // Consider encrypting the data here before writing to the filesystem
-  fs.writeFileSync(filePath, JSON.stringify(meProfile.getIdentityObject()));
-  console.log('Profile created successfully.');
-}
-
-/**
-* Function to display options and commands.
-*/
-function displayOptionsAndCommands() {
-  console.log(program.helpInformation());
-}
-
-/**
- * Lists all the .me profile file paths in the user's .me directory.
- * @returns {string[]} An array of full file paths for each .me profile.
- */
-function listMeProfiles() {
-  const meDirectory = path.join(os.homedir(), '.me');
-  if (fs.existsSync(meDirectory)) {
-      const profileFiles = fs.readdirSync(meDirectory)
-          .filter(file => file.endsWith('.me'));
-      return profileFiles.map(file => path.join(meDirectory, file));
-  } else {
-      console.log('No profiles found.');
-      return [];
-  }
-}
-
-/**
- * Prompts the user to select a .me profile or go back to the main menu.
- * @returns {Promise<string>} The file path of the selected profile or 'back' to go to the main menu.
- */
-async function selectProfile() {
-  const profiles = listMeProfiles();
-  if (profiles.length === 0) {
-      console.log('No profiles found.');
-      return 'back';
-  }
-
-  const choices = profiles.map(file => ({
-      name: path.basename(file, '.me'),
-      value: file
-  })).concat([{ name: 'Go Back to Main Menu', value: 'back' }]);
-
-  const answer = await inquirer.prompt([{
-      type: 'list',
-      name: 'selectedProfile',
-      message: 'Select a profile to view or go back:',
-      choices: choices
-  }]);
-  return answer.selectedProfile;
-}
+import { shell } from './shell.js';
 
 /**
 * Main function to handle the CLI interactions.
 * Continuously prompts the user for actions until an exit command is given.
 */
+
 async function main() {
-  welcomeToMe();
+printWelcome();
   let exit = false;
   while (!exit) {
-      const choice = await getUserChoice();
+      const choice = await shell.selectMe();
       switch (choice) {
          /**
              * Handles the 'View Existing Profiles' choice.
              * Lists and displays all existing .me profiles.
              */
          case 'View Existing Profiles':
-          const selectedProfile = await selectProfile();
+          const selectedProfile = await shell.selectProfile();
           if (selectedProfile === 'back') {
               break;
           }
@@ -195,6 +47,10 @@ async function main() {
           console.log(`Selected profile: ${selectedProfile}`);
           // Add logic to handle the selected profile
           break;
+          case 'Create New Profile':
+            const newProfile = await shell.createMe(); // Or createMe if that's the name you're using
+            shell.writeMe(newProfile);
+            break;
           case 'Exit':
               console.log('Exiting .me CLI.');
               exit = true;