unicodemanager 0.6.7

package/LICENSE

@@ -0,0 +1,35 @@
+UniCode-Manager Custom License v1.0
+
+Copyright (c) 2026 Youcef Benabdallah. All rights reserved.
+
+1. Permitted Use
+   This software may only be used to generate, scaffold, build, and manage 
+   extensions (".codix" packages) for the Unicode CLI ecosystem.
+
+2. Restrictions
+   You may NOT copy, modify, redistribute, reverse-engineer, decompile, 
+   sublicense, or otherwise reuse any portion of this package's source code, 
+   in whole or in part, for any purpose other than the permitted use stated 
+   above. This includes, without limitation, using the code as a template, 
+   incorporating it into other software, or republishing it.
+
+3. No Modification of Package Identity
+   The package name "unicodemanager" and display name "UniCode-Manager" 
+   must remain unchanged. You may not publish forks, modified versions, 
+   or derivative packages under the same or similar names.
+
+4. Disclaimer of Warranty
+   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+5. Limitation of Liability
+   IN NO EVENT SHALL THE DEVELOPER (YOUCEF BENABDALLAH) BE LIABLE FOR ANY 
+   CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 
+   OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR 
+   THE USE OR OTHER DEALINGS IN THE SOFTWARE. THE USER ASSUMES ALL RISK AND 
+   RESPONSIBILITY FOR ANY ISSUES ARISING FROM USE OF THIS SOFTWARE.
+
+6. Acceptance
+   By using this software, you accept and agree to all terms of this license. 
+   If you do not agree, you must delete all copies immediately.

package/README.md

@@ -0,0 +1,78 @@
+# UniCode-Manager
+
+**Unicode CLI extension packaging and management toolkit** — build, scaffold, and publish `.codix` extensions.
+
+Part of the [Unicode CLI](https://github.com/youcefdev/unicode) ecosystem.
+
+## Installation
+
+```bash
+npm install -g unicodemanager
+```
+
+Or use directly with `npx` (no install needed):
+
+```bash
+npx unicode build
+```
+
+## Quick Start
+
+Create a new extension:
+
+```bash
+npx unicode init my-extension
+cd my-extension
+```
+
+Build it into a `.codix` package:
+
+```bash
+npx unicode build
+```
+
+Install it into Unicode CLI:
+
+```bash
+unicode --install-extension my-extension.1.0.0.unicode.codix
+```
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `npx unicode init <name>` | Scaffold a new extension project |
+| `npx unicode build [dir]` | Build `.codix` from extension directory |
+| `npx unicode pack <dir>` | Pack extension into `.codix` (alias for build) |
+| `npx unicode --help` | Show help |
+| `npx unicode --version` | Show version |
+
+## Extension Structure
+
+```
+my-extension/
+├── extension.json      # Manifest (id, name, version, main, contributes)
+├── package.json        # Node.js package
+├── main.js             # Entry point with hook handlers
+├── node_modules/       # Dependencies (optional)
+└── .gitignore
+```
+
+## Hook Protocol
+
+Extensions communicate with the Unicode CLI via a simple subprocess protocol:
+
+```bash
+node main.js --hook on_ai_response --data "AI response text"
+```
+
+The extension writes the modified text to stdout. Supported hooks:
+
+- `on_ai_response` — Modify AI responses before display
+- `on_user_input` — Modify user input before sending to AI
+- `on_command` — Intercept commands
+
+
+
+## License
+ 2026 Youcef Benabdallah

package/bin/unicode.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// CLI entry point for `npx unicode` / `npx unicodemanager`
+require('../index.js');

package/index.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+const build = require('./lib/build');
+const init = require('./lib/init');
+const pack = require('./lib/pack');
+
+const pkg = require('./package.json');
+
+function printHelp() {
+    console.log(`
+  ${pkg.displayName} v${pkg.version}
+  ${pkg.description}
+
+  Usage:
+    npx unicode build              Build .codix from current directory
+    npx unicode init <name>        Scaffold a new extension project
+    npx unicode pack <source-dir>  Pack extension directory into .codix
+    npx unicode --help             Show this help
+    npx unicode --version          Show version
+
+  Examples:
+    npx unicode init my-extension
+    cd my-extension
+    npx unicode build
+    npx unicode --install-extension my-extension.1.0.0.unicode.codix
+`);
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+    const cmd = args[0] || '';
+
+    if (cmd === '--version' || cmd === '-v') {
+        console.log(`${pkg.version}`);
+        return;
+    }
+
+    if (cmd === '--help' || cmd === '-h' || cmd === 'help') {
+        printHelp();
+        return;
+    }
+
+    if (cmd === 'build') {
+        await build.run(args.slice(1));
+        return;
+    }
+
+    if (cmd === 'init') {
+        await init.run(args.slice(1));
+        return;
+    }
+
+    if (cmd === 'pack') {
+        await pack.run(args.slice(1));
+        return;
+    }
+
+    // No valid command
+    printHelp();
+}
+
+main().catch(err => {
+    console.error('  ✗', err.message);
+    process.exit(1);
+});

package/lib/build.js

@@ -0,0 +1,72 @@
+// lib/build.js — Build .codix from extension directory
+// Usage: npx unicode build [source-dir] [output-file]
+
+const fs = require('fs');
+const path = require('path');
+const pack = require('./pack');
+
+async function run(args) {
+    const srcDir = path.resolve(args[0] || process.cwd());
+    const outFile = args[1] || '';
+
+    // Validate source directory
+    if (!fs.existsSync(srcDir)) {
+        console.error(`  ✗ Source directory not found: ${srcDir}`);
+        process.exit(1);
+    }
+
+    // Check for manifest
+    const manifestPath = path.join(srcDir, 'extension.json');
+    const pkgPath = path.join(srcDir, 'package.json');
+
+    if (!fs.existsSync(manifestPath) && !fs.existsSync(pkgPath)) {
+        console.error(`  ✗ No extension.json or package.json found in ${srcDir}`);
+        console.error('  Run `npx unicode init <name>` to create a new extension.');
+        process.exit(1);
+    }
+
+    // Read manifest for name/version
+    let manifest;
+    try {
+        if (fs.existsSync(manifestPath)) {
+            manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        } else {
+            manifest = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        }
+    } catch (e) {
+        console.error('  ✗ Invalid manifest JSON:', e.message);
+        process.exit(1);
+    }
+
+    const name = manifest.id || manifest.name || path.basename(srcDir);
+    const version = manifest.version || '1.0.0';
+    const filename = outFile || `${name}.${version}.unicode.codix`;
+    const outPath = path.resolve(filename);
+
+    console.log(`\n  Building extension: ${name} v${version}`);
+    console.log(`  From:  ${srcDir}`);
+    console.log(`  To:    ${outPath}`);
+
+    // Ensure node_modules are installed if package.json has dependencies
+    if (fs.existsSync(pkgPath)) {
+        const pkgData = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const hasDeps = pkgData.dependencies && Object.keys(pkgData.dependencies).length > 0;
+        if (hasDeps) {
+            console.log('  Installing dependencies...');
+            const { execSync } = require('child_process');
+            try {
+                execSync('npm install --production', { cwd: srcDir, stdio: 'pipe' });
+            } catch (e) {
+                console.warn('  ⚠  npm install failed (non-fatal):', e.message);
+            }
+        }
+    }
+
+    // Pack it
+    await pack.run([srcDir, outPath]);
+
+    console.log(`  ✓ Build complete: ${filename}`);
+    console.log(`  Install: unicode --install-extension "${outPath}"`);
+}
+
+module.exports = { run };

package/lib/init.js

@@ -0,0 +1,138 @@
+// lib/init.js — Scaffold a new Unicode extension project
+// Usage: npx unicode init <extension-name>
+
+const fs = require('fs');
+const path = require('path');
+
+const TEMPLATE_FILES = {
+    'extension.json': (name, displayName) => JSON.stringify({
+        id: name,
+        name: displayName,
+        version: '1.0.0',
+        author: '',
+        description: 'A Unicode CLI extension',
+        main: 'main.js',
+        engines: { unicode: '>=0.6.0' },
+        contributes: {
+            hooks: ['on_ai_response', 'on_user_input'],
+            commands: [],
+            themes: []
+        }
+    }, null, 2),
+
+    'package.json': (name, displayName) => JSON.stringify({
+        name: name,
+        version: '1.0.0',
+        description: 'A Unicode CLI extension',
+        main: 'main.js',
+        scripts: {
+            build: 'npx unicode build',
+            test: 'node main.js --test'
+        },
+        keywords: ['unicode', 'extension', 'codix'],
+        engines: { node: '>=14.0.0' }
+    }, null, 2),
+
+    'main.js': (name) => `#!/usr/bin/env node
+
+// Unicode CLI Extension — ${name}
+// Hook protocol: called with --hook <name> --data <json-string>
+// Respond via stdout with modified string (or original to passthrough)
+
+const hooks = {
+    on_ai_response: (text) => {
+        // Modify AI responses here
+        return text;
+    },
+
+    on_user_input: (text) => {
+        // Modify user input here
+        return text;
+    },
+
+    on_command: (data) => {
+        // Intercept commands here
+        return data;
+    }
+};
+
+function main() {
+    const args = process.argv.slice(2);
+    let hook = '';
+    let data = '';
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--hook' && i + 1 < args.length) hook = args[++i];
+        else if (args[i] === '--data' && i + 1 < args.length) data = args[++i];
+    }
+
+    if (hook && hooks[hook]) {
+        process.stdout.write(hooks[hook](data));
+    } else if (hook) {
+        process.stdout.write(data);
+    } else {
+        const pkg = require('./package.json');
+        process.stdout.write(JSON.stringify({
+            id: pkg.name,
+            name: pkg.name,
+            version: pkg.version,
+            description: pkg.description,
+            hooks: Object.keys(hooks)
+        }));
+    }
+}
+
+main();
+`,
+
+    '.gitignore': () => `node_modules/
+*.zip
+*.codix
+`,
+};
+
+function run(args) {
+    const extName = args[0];
+    if (!extName) {
+        console.log('  Usage: npx unicode init <extension-name>');
+        console.log('  Example: npx unicode init my-cool-extension');
+        process.exit(1);
+    }
+
+    // Validate name
+    if (!/^[a-z0-9][a-z0-9_-]*$/i.test(extName)) {
+        console.error('  ✗ Extension name must start with a letter or number and contain only letters, numbers, hyphens, and underscores.');
+        process.exit(1);
+    }
+
+    const destDir = path.resolve(extName);
+    if (fs.existsSync(destDir)) {
+        console.error(`  ✗ Directory already exists: ${destDir}`);
+        process.exit(1);
+    }
+
+    const displayName = extName
+        .replace(/[-_]/g, ' ')
+        .replace(/\b\w/g, c => c.toUpperCase());
+
+    console.log(`\n  Creating extension: ${extName}`);
+    console.log(`  At: ${destDir}`);
+
+    fs.mkdirSync(destDir, { recursive: true });
+
+    // Write template files
+    for (const [filename, generator] of Object.entries(TEMPLATE_FILES)) {
+        const content = generator(extName, displayName);
+        fs.writeFileSync(path.join(destDir, filename), content, 'utf-8');
+        console.log(`  ✓ Created: ${filename}`);
+    }
+
+    console.log(`\n  ✓ Extension scaffolded successfully!`);
+    console.log(`\n  Next steps:`);
+    console.log(`    cd ${extName}`);
+    console.log(`    npm install`);
+    console.log(`    # Edit main.js to add your logic`);
+    console.log(`    npx unicode build           # Package as .codix`);
+}
+
+module.exports = { run };

package/lib/pack.js

@@ -0,0 +1,77 @@
+// lib/pack.js — Pack extension directory into .codix (ZIP archive)
+// Usage: npx unicode pack <source-dir> [output-file]
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch {
+        return null;
+    }
+}
+
+async function run(args) {
+    const srcDir = path.resolve(args[0] || process.cwd());
+    const outFile = args[1] || '';
+
+    // Validate source
+    if (!fs.existsSync(srcDir)) {
+        console.error(`  ✗ Source directory not found: ${srcDir}`);
+        process.exit(1);
+    }
+
+    // Read manifest
+    let manifest = readJson(path.join(srcDir, 'extension.json'));
+    if (!manifest) manifest = readJson(path.join(srcDir, 'package.json'));
+    if (!manifest) {
+        console.error(`  ✗ No extension.json or package.json found in ${srcDir}`);
+        process.exit(1);
+    }
+
+    const name = manifest.id || manifest.name || 'extension';
+    const version = manifest.version || '1.0.0';
+    const filename = outFile || `${name}.${version}.unicode.codix`;
+    const outPath = path.resolve(filename);
+
+    console.log(`  Packaging: ${name} v${version}`);
+    console.log(`  From:      ${srcDir}`);
+    console.log(`  To:        ${outPath}`);
+
+    // Create ZIP via PowerShell Compress-Archive, then rename .zip → .codix
+    const tmpZip = outPath.replace(/\.codix$/, '.zip');
+    const cmd = `powershell -NoProfile -Command "Compress-Archive -Path '${srcDir}\\*' -DestinationPath '${tmpZip}' -Force"`;
+
+    try {
+        execSync(cmd, { stdio: 'pipe', timeout: 30000 });
+    } catch (e) {
+        console.error('  ✗ Failed to create archive:', e.message);
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(tmpZip)) {
+        console.error('  ✗ Archive was not created');
+        process.exit(1);
+    }
+
+    // Rename .zip → .codix
+    try {
+        // Remove existing output if any
+        if (fs.existsSync(outPath)) fs.unlinkSync(outPath);
+        fs.renameSync(tmpZip, outPath);
+    } catch (e) {
+        console.error('  ✗ Failed to rename archive:', e.message);
+        process.exit(1);
+    }
+
+    // Show size
+    const size = fs.statSync(outPath).size;
+    const sizeStr = size > 1024 * 1024
+        ? (size / 1024 / 1024).toFixed(1) + ' MB'
+        : (size / 1024).toFixed(1) + ' KB';
+    console.log(`  ✓ Packed: ${filename} (${sizeStr})`);
+}
+
+module.exports = { run };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "unicodemanager",
+  "displayName": "UniCode-Manager",
+  "version": "0.6.7",
+  "description": "Unicode CLI extension packaging and management toolkit — build, scaffold, and publish .codix extensions",
+  "author": "Youcef Benabdallah",
+  "license": "MIT",
+  "main": "index.js",
+  "bin": {
+    "unicode": "bin/unicode.js",
+    "unicodemanager": "bin/unicode.js"
+  },
+  "keywords": [
+    "unicode",
+    "cli",
+    "extension",
+    "codix",
+    "plugin",
+    "ai",
+    "agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/youcefdev/unicode"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "index.js",
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node bin/unicode.js build",
+    "start": "node bin/unicode.js",
+    "pack": "node bin/unicode.js pack",
+    "init": "node bin/unicode.js init"
+  }
+}