mojic 1.0.0

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,34 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at **amitdutta4255@gmail.com** or **mail@amit.is-a.dev**. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org 
+[version]: http://contributor-covenant.org/version/1/4/

package/CONTRIBUTING.md

@@ -0,0 +1,39 @@
+# Contributing to Emojic
+
+First off, thanks for taking the time to contribute! 🎉
+
+The following is a set of guidelines for contributing to Emojic. These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
+
+## How Can I Contribute?
+
+### Reporting Bugs
+
+This section guides you through submitting a bug report for Emojic. Following these guidelines helps maintainers and the community understand your report, reproduce the behavior, and find related reports.
+
+* **Use a clear and descriptive title** for the issue to identify the problem.
+* **Describe the exact steps which reproduce the problem** in as many details as possible.
+* **Provide specific examples** to demonstrate the steps.
+
+### Suggesting Enhancements
+
+This section guides you through submitting an enhancement suggestion for Emojic, including completely new features and minor improvements to existing functionality.
+
+* **Use a clear and descriptive title** for the issue to identify the suggestion.
+* **Provide a step-by-step description of the suggested enhancement** in as many details as possible.
+* **Explain why this enhancement would be useful** to most Emojic users.
+
+## Styleguides
+
+### Git Commit Messages
+
+* Use the present tense ("Add feature" not "Added feature")
+* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+* Limit the first line to 72 characters or less
+* Reference issues and pull requests liberally after the first line
+
+### Emojic Code Style
+
+* If you are writing Emojic examples, try to make them as unreadable as possible.
+* Use `😒` for `int` whenever possible.
+
+Happy Hacking! 🚀

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,70 @@
+# Emojic 🤯
+
+> A chaotic, emoji-based C transpiler and IDE. Write C code using emojis, compile it, or transform normal C into a cursed emoji nightmare.
+
+
+## What is this?
+
+**Emojic** is a dangerous experiment in compiler theory. It allows you to write valid C code using emojis as preprocessor definitions. It comes with a full-stack **Emojic Studio** IDE that lets you:
+
+1.  **Compile Emojic to C**: Turn `😒 😊😂🤣👌` into `int main()`.
+2.  **Transform C to Emojic**: Turn your clean code into an unreadable emoji mess.
+3.  **Run in Cloud**: Execute your cursed code instantly via the `compiler.amit.is-a.dev` backend.
+
+## 🚀 Features
+
+- **Dynamic Token Analysis**: Automatically detects keywords in your C code.
+- **Custom Mapping**: Choose which emojis represent `int`, `return`, or `;`.
+- **Live Terminal**: Real-time output streaming via WebSockets.
+- **Dark Mode IDE**: A VS Code-like experience in the browser.
+
+## 🛠️ Installation & Deployment
+
+This project is designed to be deployed on **Vercel** (Frontend + API).
+
+1.  **Clone the repo**
+    ```bash
+    git clone [https://github.com/notamitgamer/](https://github.com/notamitgamer/)emojic.git
+    cd emojic
+    ```
+
+2.  **Install Backend Dependencies**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+3.  **Run Locally**
+    ```bash
+    python api/index.py
+    # Open index.html in your browser
+    ```
+
+## 😒 Example Code
+
+```c
+/* The Hello World of Emojic */
+#include<stdio.h>
+
+#define 😒 int
+#define 😊 main
+#define 😂 (
+#define 🤣 )
+#define ❤️ printf
+#define 😍 ;
+#define 🙌 return
+#define 👌 {
+#define 😘 }
+
+😒 😊😂🤣👌
+    ❤️😂"Hello World!\n"🤣😍
+    🙌 0😍
+😘
+```
+
+## 🤝 Contributing
+
+We welcome chaos! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+We take security seriously, even if this project is a joke.
+
+If you discover a security vulnerability within Emojic, please send an e-mail to **amitdutta4255@gmail.com**. All security vulnerabilities will be promptly addressed.
+
+**Please do not open public issues for security vulnerabilities.**

package/bin/mojic.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { Transform } from 'stream';
+import { StringDecoder } from 'string_decoder';
+import { CipherEngine } from '../lib/CipherEngine.js';
+
+program
+    .name('mojic')
+    .description('Obfuscate C source code into emojis')
+    .version('1.0.0')
+    .addHelpCommand('help [command]', 'Display help for command')
+    .showHelpAfterError();
+
+// --- Helpers ---
+
+const promptPassword = async (msg) => {
+    const { password } = await inquirer.prompt([{
+        type: 'password', name: 'password', message: msg, mask: '*',
+        validate: (input) => input.length > 5 || 'Password must be > 5 chars.'
+    }]);
+    return password;
+};
+
+const getStreamHeader = async (filePath) => {
+    const fileStream = fs.createReadStream(filePath, { highWaterMark: 1024 });
+    const decoder = new StringDecoder('utf8');
+    
+    return new Promise((resolve, reject) => {
+        let buffer = '';
+        let found = false;
+        
+        fileStream.on('data', (chunk) => {
+            if (found) return;
+            buffer += decoder.write(chunk);
+            const newlineIndex = buffer.indexOf('\n');
+            if (newlineIndex !== -1) {
+                found = true;
+                fileStream.destroy();
+                resolve(buffer.substring(0, newlineIndex));
+            }
+        });
+        
+        fileStream.on('end', () => {
+            if (!found) resolve(buffer + decoder.end());
+        });
+        fileStream.on('error', reject);
+    });
+};
+
+const createHeaderSkipper = () => {
+    const decoder = new StringDecoder('utf8');
+    let isHeaderSkipped = false;
+    let buffer = '';
+
+    return new Transform({
+        transform(chunk, encoding, cb) {
+            if (isHeaderSkipped) {
+                this.push(chunk);
+                return cb();
+            }
+            
+            buffer += decoder.write(chunk);
+            const nlIndex = buffer.indexOf('\n');
+            
+            if (nlIndex !== -1) {
+                const remainder = buffer.substring(nlIndex + 1);
+                this.push(remainder);
+                isHeaderSkipped = true;
+                buffer = '';
+            }
+            cb();
+        }
+    });
+};
+
+// --- Recursive Logic ---
+
+async function traverseDirectory(currentPath, extension, callback) {
+    const entries = fs.readdirSync(currentPath, { withFileTypes: true });
+    
+    for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+            await traverseDirectory(fullPath, extension, callback);
+        } else if (entry.isFile() && entry.name.endsWith(extension)) {
+            await callback(fullPath);
+        }
+    }
+}
+
+// --- Main Commands ---
+
+program
+    .command('encode')
+    .argument('<path>', 'File or Directory to encode')
+    .option('-r, --recursive', 'Recursively encrypt all .c files in directory')
+    .description('Encrypt a file or directory into emojis')
+    .action(async (targetPath, options) => {
+        try {
+            if (!fs.existsSync(targetPath)) throw new Error('Path not found');
+            const stats = fs.statSync(targetPath);
+
+            // Validation
+            if (stats.isDirectory() && !options.recursive) {
+                throw new Error(`'${targetPath}' is a directory. Use -r to process recursively.`);
+            }
+
+            console.log(chalk.blue('🔒 Initiating Mojic Encryption...'));
+            const password = await promptPassword('Create password for file(s):');
+
+            const processFile = async (filePath) => {
+                const outputName = filePath.replace(/\.c$/, '') + '.mojic';
+                console.log(chalk.dim(`   Processing: ${path.basename(filePath)} -> ${path.basename(outputName)}`));
+
+                const engine = new CipherEngine(password);
+                await engine.init(); // Unique salt per file
+                
+                const readStream = fs.createReadStream(filePath);
+                const writeStream = fs.createWriteStream(outputName);
+                
+                writeStream.write(engine._encodeHeader());
+                
+                await new Promise((resolve, reject) => {
+                    readStream
+                        .pipe(engine.getEncryptStream())
+                        .pipe(writeStream)
+                        .on('finish', resolve)
+                        .on('error', reject);
+                });
+            };
+
+            if (stats.isDirectory()) {
+                console.log(chalk.blue(`📂 Scanning directory: ${targetPath}`));
+                await traverseDirectory(targetPath, '.c', processFile);
+                console.log(chalk.green('✅ Batch encryption complete.'));
+            } else {
+                await processFile(targetPath);
+                console.log(chalk.green(`✅ Encrypted.`));
+            }
+
+        } catch (err) {
+            console.error(chalk.red('Error:'), err.message);
+        }
+    });
+
+program
+    .command('decode')
+    .argument('<path>', 'File or Directory to decode')
+    .option('-r, --recursive', 'Recursively decode all .mojic files')
+    .description('Restore mojic files to C source code')
+    .action(async (targetPath, options) => {
+        try {
+            if (!fs.existsSync(targetPath)) throw new Error('Path not found');
+            const stats = fs.statSync(targetPath);
+
+            if (stats.isDirectory() && !options.recursive) {
+                throw new Error(`'${targetPath}' is a directory. Use -r to process recursively.`);
+            }
+
+            console.log(chalk.blue('🔓 Initiating Decryption...'));
+            const password = await promptPassword('Enter password:'); // Assume same pass for dir
+
+            const processFile = async (filePath) => {
+                try {
+                    const outputName = filePath.replace(/\.mojic$/, '') + '.restored.c';
+                    console.log(chalk.dim(`   Restoring: ${path.basename(filePath)}`));
+
+                    const headerStr = await getStreamHeader(filePath);
+                    const metadata = CipherEngine.decodeHeader(headerStr);
+                    
+                    const engine = new CipherEngine(password);
+                    await engine.init(metadata.saltHex);
+
+                    if (engine.authHash.toString('hex') !== metadata.authHex) {
+                        console.log(chalk.red(`   ❌ Skipped ${path.basename(filePath)}: Incorrect Password`));
+                        return;
+                    }
+
+                    const readStream = fs.createReadStream(filePath);
+                    const writeStream = fs.createWriteStream(outputName);
+                    
+                    await new Promise((resolve, reject) => {
+                        readStream
+                            .pipe(createHeaderSkipper())
+                            .pipe(engine.getDecryptStream())
+                            .pipe(writeStream)
+                            .on('finish', resolve)
+                            .on('error', reject);
+                    });
+                } catch (e) {
+                    console.log(chalk.red(`   ⚠️ Error processing ${path.basename(filePath)}: ${e.message}`));
+                }
+            };
+
+            if (stats.isDirectory()) {
+                console.log(chalk.blue(`📂 Scanning directory: ${targetPath}`));
+                await traverseDirectory(targetPath, '.mojic', processFile);
+                console.log(chalk.green('✅ Batch decryption complete.'));
+            } else {
+                await processFile(targetPath);
+                console.log(chalk.green(`✅ Restored.`));
+            }
+
+        } catch (err) {
+            console.error(chalk.red('Error:'), err.message);
+        }
+    });
+
+// --- Security Rotation Tools (SRT) ---
+
+const rotatePassword = async (file) => {
+    try {
+        if (!fs.existsSync(file)) throw new Error('File not found');
+        console.log(chalk.yellow(`🔄 Rotating Password for ${path.basename(file)}...`));
+
+        // 1. Authenticate Old
+        const headerStr = await getStreamHeader(file);
+        const metadata = CipherEngine.decodeHeader(headerStr);
+        const oldPass = await promptPassword('Enter CURRENT password:');
+        
+        const oldEngine = new CipherEngine(oldPass);
+        await oldEngine.init(metadata.saltHex);
+
+        if (oldEngine.authHash.toString('hex') !== metadata.authHex) {
+            console.error(chalk.red('❌ Incorrect Current Password'));
+            process.exit(1);
+        }
+
+        // 2. Init New
+        const newPass = await promptPassword('Enter NEW password:');
+        const newEngine = new CipherEngine(newPass);
+        await newEngine.init(); 
+
+        // 3. Process
+        const tempFile = file + '.tmp';
+        const readStream = fs.createReadStream(file);
+        const writeStream = fs.createWriteStream(tempFile);
+
+        writeStream.write(newEngine._encodeHeader());
+
+        await new Promise((resolve, reject) => {
+            readStream
+                .pipe(createHeaderSkipper())
+                .pipe(oldEngine.getDecryptStream())
+                .pipe(newEngine.getEncryptStream())
+                .pipe(writeStream)
+                .on('finish', resolve)
+                .on('error', reject);
+        });
+
+        fs.renameSync(tempFile, file);
+        console.log(chalk.green(`✅ Password updated.`));
+        
+    } catch (err) {
+        console.error(chalk.red('Error:'), err.message);
+    }
+};
+
+const reEncrypt = async (file) => {
+    try {
+        if (!fs.existsSync(file)) throw new Error('File not found');
+        console.log(chalk.yellow(`🎲 Re-shuffling Entropy for ${path.basename(file)}...`));
+
+        // 1. Authenticate
+        const headerStr = await getStreamHeader(file);
+        const metadata = CipherEngine.decodeHeader(headerStr);
+        const password = await promptPassword('Enter password:');
+        
+        const oldEngine = new CipherEngine(password);
+        await oldEngine.init(metadata.saltHex);
+
+        if (oldEngine.authHash.toString('hex') !== metadata.authHex) {
+            console.error(chalk.red('❌ Incorrect Password'));
+            process.exit(1);
+        }
+
+        // 2. Init New
+        const newEngine = new CipherEngine(password);
+        await newEngine.init(); 
+
+        // 3. Process
+        const tempFile = file + '.tmp';
+        const readStream = fs.createReadStream(file);
+        const writeStream = fs.createWriteStream(tempFile);
+
+        writeStream.write(newEngine._encodeHeader());
+
+        await new Promise((resolve, reject) => {
+            readStream
+                .pipe(createHeaderSkipper())
+                .pipe(oldEngine.getDecryptStream())
+                .pipe(newEngine.getEncryptStream())
+                .pipe(writeStream)
+                .on('finish', resolve)
+                .on('error', reject);
+        });
+
+        fs.renameSync(tempFile, file);
+        console.log(chalk.green(`✅ File re-encrypted.`));
+
+    } catch (err) {
+        console.error(chalk.red('Error:'), err.message);
+    }
+};
+
+program
+    .command('srt')
+    .description('Security and Rotation Tools')
+    .option('--pass <file>', 'Update the password for an existing file')
+    .option('--re <file>', 'Re-encrypt with new random seed (Same password)')
+    .addHelpText('after', `
+Examples:
+  $ mojic srt --pass secret.mojic   # Change the password of an encrypted file
+  $ mojic srt --re secret.mojic     # Re-scramble the emojis (new salt) with same password
+`)
+    .action(async (options) => {
+        if (options.pass) {
+            await rotatePassword(options.pass);
+        } else if (options.re) {
+            await reEncrypt(options.re);
+        } else {
+            console.log(chalk.yellow('Please specify an option: --pass <file> or --re <file>'));
+            program.commands.find(c => c.name() === 'srt').help();
+        }
+    });
+
+program.addHelpText('after', `
+Usage Examples:
+  $ mojic encode test.c          # Encrypt a single C file
+  $ mojic encode ./src -r        # Recursively encrypt all .c files in ./src
+  $ mojic decode test.mojic      # Decrypt a single file
+  $ mojic decode ./src -r        # Recursively decrypt all .mojic files
+`);
+
+program.parse(process.argv);

package/lib/CipherEngine.js

@@ -0,0 +1,253 @@
+import crypto from 'crypto';
+import { Transform } from 'stream';
+import { StringDecoder } from 'string_decoder';
+
+/**
+ * Emojic CipherEngine
+ * Handles the logic for mapping C-code to Emojis based on a password seed.
+ * * * Updates:
+ * - Uses Intl.Segmenter for robust Emoji/Grapheme decoding.
+ * - Implements 'tail buffering' in streams to prevent splitting multi-codepoint emojis.
+ */
+
+const HEADER_ALPHABET = ['🌑', '🌒', '🌓', '🌔', '🌕', '🌖', '🌗', '🌘', '🕐', '🕑', '🕒', '🕓', '🕔', '🕕', '🕖', '🕗'];
+
+const EMOJI_UNIVERSE = [
+    '😀','😃','😄','😁','😆','😅','🤣','😂','🙂','🙃','😉','😊','😇','🥰','😍','🤩',
+    '😘','😗','☺️','😚','😙','🥲','😋','😛','😜','🤪','😝','🤑','🤗','🤭','🤫','🤔',
+    '🤐','🤨','😐','😑','😶','😏','😒','🙄','😬','🤥','😌','😔','😪','🤤','😴','😷',
+    '🤒','🤕','🤢','🤮','🤧','🥵','🥶','🥴','😵','🤯','🤠','🥳','😎','🤓','🧐','😕',
+    '😟','🙁','☹️','😮','😯','😲','😳','🥺','😦','😧','😨','😰','😥','😢','😭','😱',
+    '😖','😣','😞','😓','😩','😫','🥱','😤','😡','😠','🤬','😈','👿','💀','☠️','💩',
+    '🤡','👹','👺','👻','👽','👾','🤖','😺','😸','😹','😻','😼','😽','🙀','😿','😾',
+    '🙈','🙉','🙊','💋','💌','💘','💝','💖','💗','💓','💞','💕','💟','❣️','💔','❤️',
+    '🧡','💛','💚','💙','💜','🤎','🖤','🤍','💯','💢','💥','💫','💦','💨','🕳️','💣',
+    '💬','👁️','💭','💤','👋','🤚','🖐️','✋','🖖','👌','🤏','✌️','🤞','🤟','🤘',
+    '🤙','👈','👉','👆','🖕','👇','☝️','👍','👎','✊','👊','🤛','🤜','👏','🙌','👐',
+    '🤲','🤝','🙏','✍️','💅','🤳','💪','🦾','🦿','🦵','🦶','👂','🦻','👃','🧠','🫀',
+    '🫁','🦷','🦴','👀','👅','👄','👶','🧒','👦','👧','🧑','👱','👨','🧔','👨‍🦰','👨‍🦱',
+    '🔥','🌈','☀️','⛈️','🌩️','❄️','🌵','🌷','🌲','🌳','🌴','🐲','🐉','🦕','🦖','🐍',
+    '🐎','🦄','🦓','🐆','🐅','🐂','🐄','🐖','🐏','🐑','🐐','🐪','🐫','🦙','🦒','🐘',
+    '🦏','🦛','🐁','🐀','🐹','🐰','🐇','🐿️','🦔','🦇','🐻','🐨','🐼','🦥','🦦','🦨',
+    '🦘','🦡','🐾','🦃','🐔','🐓','🐣','🐤','🐥','🐦','🐧','🕊️','🦅','🦆','🦢','🦉',
+    '🎈','🧨','🧧','🎀','🎁','🎗️','🎟️','🎫','🎖️','🏆','🏅','🥇','🥈','🥉','⚽','⚾',
+    '🥎','🏀','🏐','🏈','🏉','🎾','🥏','🎳','🏏','🏑','🏒','🥍','🏓','🏸','🥊','🥋',
+    '🥅','⛳','⛸️','🎣','🤿','🎽','🎿','🛷','🥌','🎯','🪀','🪁','🎱','🔮','🧿','🎮'
+];
+
+const C_KEYWORDS = [
+    'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do',
+    'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if',
+    'int', 'long', 'register', 'return', 'short', 'signed', 'sizeof', 'static',
+    'struct', 'switch', 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while',
+    'include', 'define', 'main', 'printf', 'NULL'
+];
+
+const ASCII_CHARS = Array.from({ length: 95 }, (_, i) => String.fromCharCode(i + 32))
+    .concat(['\n', '\t', '\r']);
+
+const TOTAL_TOKENS = C_KEYWORDS.length + ASCII_CHARS.length;
+
+export class CipherEngine {
+    constructor(password) {
+        this.password = password;
+        this.tokenMap = new Map();
+        this.reverseMap = new Map();
+        this.isReady = false;
+        
+        if (EMOJI_UNIVERSE.length < TOTAL_TOKENS) {
+            throw new Error(`CRITICAL: Not enough emojis. Need ${TOTAL_TOKENS}, have ${EMOJI_UNIVERSE.length}`);
+        }
+    }
+
+    async init(existingSaltHex = null) {
+        this.salt = existingSaltHex 
+            ? Buffer.from(existingSaltHex, 'hex') 
+            : crypto.randomBytes(16);
+
+        const derivedKey = await new Promise((resolve, reject) => {
+            crypto.pbkdf2(this.password, this.salt, 100000, 36, 'sha256', (err, key) => {
+                if (err) reject(err); else resolve(key);
+            });
+        });
+
+        const seedBuffer = derivedKey.subarray(0, 4);
+        this.authHash = derivedKey.subarray(4);
+        const seedInt = seedBuffer.readUInt32BE(0);
+
+        const shuffledEmojis = this._shuffleArray([...EMOJI_UNIVERSE], seedInt);
+
+        let emojiIndex = 0;
+        for (const keyword of C_KEYWORDS) {
+            const emo = shuffledEmojis[emojiIndex++];
+            this.tokenMap.set(keyword, emo);
+            this.reverseMap.set(emo, keyword);
+        }
+
+        for (const char of ASCII_CHARS) {
+            const emo = shuffledEmojis[emojiIndex++];
+            this.tokenMap.set(char, emo);
+            this.reverseMap.set(emo, char);
+        }
+
+        this.isReady = true;
+    }
+
+    _mulberry32(a) {
+        return function() {
+          var t = a += 0x6D2B79F5;
+          t = Math.imul(t ^ t >>> 15, t | 1);
+          t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+          return ((t ^ t >>> 14) >>> 0) / 4294967296;
+        }
+    }
+
+    _shuffleArray(array, seed) {
+        const rng = this._mulberry32(seed);
+        for (let i = array.length - 1; i > 0; i--) {
+            const j = Math.floor(rng() * (i + 1));
+            [array[i], array[j]] = [array[j], array[i]];
+        }
+        return array;
+    }
+
+    _encodeHeader() {
+        const saltHex = this.salt.toString('hex');
+        const authHex = this.authHash.toString('hex');
+        const fullHexString = saltHex + authHex;
+
+        let headerStr = '';
+        for (const char of fullHexString) {
+            const val = parseInt(char, 16);
+            headerStr += HEADER_ALPHABET[val];
+        }
+        return headerStr + '\n';
+    }
+
+    static decodeHeader(headerStr) {
+        let hexString = '';
+        // Use segmenter here just in case moon emojis have variation selectors
+        const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+        const segments = segmenter.segment(headerStr.trim());
+
+        for (const { segment } of segments) {
+            const index = HEADER_ALPHABET.indexOf(segment);
+            if (index === -1) throw new Error("Invalid Header format.");
+            hexString += index.toString(16);
+        }
+        const saltHex = hexString.substring(0, 32);
+        const authHex = hexString.substring(32);
+        return { saltHex, authHex };
+    }
+
+    getEncryptStream() {
+        if (!this.isReady) throw new Error("Engine not initialized");
+        const engine = this;
+        const decoder = new StringDecoder('utf8');
+        let buffer = '';
+
+        return new Transform({
+            transform(chunk, encoding, callback) {
+                buffer += decoder.write(chunk);
+                
+                const sortedKeywords = [...C_KEYWORDS].sort((a, b) => b.length - a.length);
+                const keywordPattern = sortedKeywords.map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+                const regex = new RegExp(`\\b(${keywordPattern})\\b|([\\s\\S])`, 'g');
+                
+                let match;
+                let output = '';
+                
+                while ((match = regex.exec(buffer)) !== null) {
+                    const token = match[0];
+                    if (engine.tokenMap.has(token)) {
+                        output += engine.tokenMap.get(token);
+                    } else {
+                        output += token; 
+                    }
+                }
+                
+                buffer = ''; 
+                this.push(output);
+                callback();
+            },
+            flush(callback) {
+                buffer += decoder.end();
+                // Simple flush for MVP; in prod, we'd regex one last time.
+                callback();
+            }
+        });
+    }
+
+    getDecryptStream() {
+        if (!this.isReady) throw new Error("Engine not initialized");
+        const engine = this;
+        const decoder = new StringDecoder('utf8');
+        const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+        
+        let buffer = '';
+
+        return new Transform({
+            transform(chunk, encoding, callback) {
+                // 1. Decode bytes to string (handles partial UTF8 bytes)
+                buffer += decoder.write(chunk);
+                
+                // 2. Segment into Graphemes (Emojis)
+                const segments = [...segmenter.segment(buffer)];
+                
+                // 3. Process all BUT the last segment
+                // We keep the last segment in the buffer because it might be 
+                // the start of a multi-codepoint emoji that was split by the chunk boundary.
+                // (e.g. Base char is here, Variation Selector is in next chunk)
+                
+                const processUntilIndex = segments.length > 1 ? segments.length - 1 : 0;
+                let output = '';
+                let processedString = '';
+
+                // If we only have 1 segment, we can't be sure it's complete, wait for next chunk
+                // UNLESS the buffer is getting huge, then force it.
+                if (segments.length === 1 && buffer.length < 100) {
+                     // Wait for more data
+                     callback();
+                     return;
+                }
+
+                // Process safe segments
+                for (let i = 0; i < processUntilIndex; i++) {
+                    const char = segments[i].segment;
+                    processedString += char;
+                    
+                    if (engine.reverseMap.has(char)) {
+                        output += engine.reverseMap.get(char);
+                    } else {
+                        output += char;
+                    }
+                }
+
+                // Update buffer to only contain the remaining tail
+                // Note: buffer might contain bytes not yet in segments if StringDecoder held them? 
+                // No, decoder.write returns what is available.
+                // We just need to remove the processed part from the buffer string.
+                if (processUntilIndex > 0) {
+                    buffer = buffer.slice(processedString.length);
+                    this.push(output);
+                }
+                
+                callback();
+            },
+            flush(callback) {
+                // Process any remaining tail (buffer + decoder leftovers)
+                buffer += decoder.end();
+                if (buffer) {
+                    const segments = segmenter.segment(buffer);
+                    let output = '';
+                    for (const { segment } of segments) {
+                        if (engine.reverseMap.has(segment)) output += engine.reverseMap.get(segment);
+                        else output += segment;
+                    }
+                    this.push(output);
+                }
+                callback();
+            }
+        });
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "mojic",
+  "version": "1.0.0",
+  "description": "Obfuscate C source code into emojis using password-seeded mapping",
+  "main": "bin/mojic.js",
+  "bin": {
+    "mojic": "bin/mojic.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node bin/mojic.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "inquirer": "^9.2.12"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "cli",
+    "encryption",
+    "emoji",
+    "obfuscation",
+    "c",
+    "security"
+  ],
+  "author": "",
+  "license": "Apache-2.0"
+}