@contextai-core/cli 0.0.1

package/LICENSE

@@ -0,0 +1,14 @@
+ContextAI CLI - Proprietary License
+
+Copyright (c) 2024 ContextAI
+
+All rights reserved.
+
+This software and associated documentation files (the "Software") are proprietary 
+and confidential. Unauthorized copying, distribution, modification, public display, 
+or public performance of this Software is strictly prohibited.
+
+The Software is provided for use solely by authorized users who have agreed to 
+the ContextAI Terms of Service.
+
+For licensing inquiries, contact: support@contextai.in

package/index.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import fs from 'fs';
+import path from 'path';
+
+// Actions
+import { login, logout, whoami } from './src/actions/auth.js';
+import { init } from './src/actions/init.js';
+import { publish } from './src/actions/publish.js';
+import { installPackage } from './src/actions/install.js';
+import { doctor } from './src/actions/doctor.js';
+
+// Helper to load env from local .env for testing
+if (fs.existsSync('.env')) {
+    const envConfig = fs.readFileSync('.env', 'utf8');
+    envConfig.split('\n').forEach(line => {
+        const [key, value] = line.split('=');
+        if (key && value) {
+            process.env[key.trim()] = value.trim();
+        }
+    });
+}
+
+const program = new Command();
+
+console.log(
+    chalk.blue(
+        figlet.textSync('ContextAI', { horizontalLayout: 'full' })
+    )
+);
+
+program
+    .version('1.0.0')
+    .description('ContextAI CLI - The npm for AI Context');
+
+// AUTH COMMANDS
+program.command('login').description('Authenticate with ContextAI via GitHub').action(login);
+program.command('whoami').description('Show current logged in user').action(whoami);
+program.command('logout').description('Log out and remove saved credentials').action(logout);
+
+// CORE COMMANDS
+program.command('init').description('Initialize a new .ai/ context in the current directory').action(init);
+program.command('doctor').description('Check environment for issues').action(doctor);
+
+program
+    .command('install <package_name>')
+    .description('Install a context package (e.g., @stacks/nextjs-stack)')
+    .action(async (packageName) => {
+        await installPackage(packageName);
+    });
+
+program
+    .command('update <package_name>')
+    .description('Update/Re-install a context package')
+    .action(async (packageName) => {
+        await installPackage(packageName);
+    });
+
+program
+    .command('list')
+    .description('List installed context packages')
+    .action(() => {
+        const aiDir = path.join(process.cwd(), '.ai');
+        const manifestPath = path.join(aiDir, 'context.json');
+
+        if (!fs.existsSync(manifestPath)) {
+            console.log(chalk.yellow('No .ai/ context found. Run `contextai init` first.'));
+            return;
+        }
+
+        try {
+            const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+            const packages = manifest.packages || {};
+
+            console.log(chalk.bold('\nInstalled Packages:\n'));
+
+            const count = Object.keys(packages).length;
+            if (count === 0) {
+                console.log(chalk.gray('  (No packages installed)'));
+            }
+
+            Object.keys(packages).forEach(pkgName => {
+                const pkg = packages[pkgName];
+                console.log(chalk.cyan(`  ${pkgName}`));
+                console.log(chalk.gray(`    Type: ${pkg.type}`));
+                console.log(chalk.gray(`    Path: ${pkg.path}`));
+                if (pkg.installedAt) console.log(chalk.gray(`    Installed: ${new Date(pkg.installedAt).toLocaleString()}`));
+                console.log('');
+            });
+
+        } catch (e) {
+            console.error(chalk.red('Error reading context manifest.'));
+            console.error(e);
+        }
+    });
+
+program.command('publish').description('Publish a context package to the registry').action(publish);
+
+// LEGACY COMMANDS
+program
+    .command('pull <slug>')
+    .description('DEPRECATED: Use install')
+    .action(async (slug) => {
+        console.warn(chalk.yellow('\n⚠️  WARNING: `contextai pull` is deprecated. Please use `contextai install` instead.\n'));
+        console.log(chalk.gray(`Attempting legacy pull for ${slug} -> install...`));
+        await installPackage(slug);
+    });
+
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "@contextai-core/cli",
+    "version": "0.0.1",
+    "description": "The npm for AI Context - install context packs for your AI agents",
+    "author": "ContextAI",
+    "license": "SEE LICENSE IN LICENSE",
+    "keywords": [
+        "ai",
+        "context",
+        "llm",
+        "cli",
+        "agents",
+        "cursor",
+        "windsurf"
+    ],
+    "main": "index.js",
+    "bin": {
+        "contextai": "index.js"
+    },
+    "type": "module",
+    "dependencies": {
+        "@supabase/supabase-js": "^2.89.0",
+        "adm-zip": "^0.5.16",
+        "chalk": "^5.3.0",
+        "commander": "^11.1.0",
+        "figlet": "^1.7.0",
+        "node-fetch": "^3.3.2",
+        "open": "^11.0.0",
+        "ora": "^8.0.0"
+    }
+}

package/src/actions/auth.js

@@ -0,0 +1,149 @@
+import fs from 'fs';
+import path from 'path';
+import http from 'http';
+import url from 'url';
+import os from 'os';
+import chalk from 'chalk';
+import open from 'open';
+import { createClient } from '@supabase/supabase-js';
+
+// Config file location
+const CONFIG_DIR = path.join(os.homedir(), '.contextai');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'credentials.json');
+
+// Load saved credentials if they exist
+function loadCredentials() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+    return null;
+}
+
+// Save credentials
+function saveCredentials(creds) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(creds, null, 2));
+}
+
+export async function login() {
+    const supabaseUrl = process.env.VITE_SUPABASE_URL;
+    const supabaseKey = process.env.VITE_SUPABASE_ANON_KEY;
+
+    if (!supabaseUrl || !supabaseKey) {
+        console.error(chalk.red('❌ Error: Supabase URL and Key must be set.'));
+        process.exit(1);
+    }
+
+    console.log(chalk.blue('🔐 Starting authentication...'));
+
+    // Start temporary HTTP server to catch callback
+    const PORT = 3333;
+    const REDIRECT_URI = `http://localhost:${PORT}/callback`;
+
+    const server = http.createServer(async (req, res) => {
+        const reqUrl = url.parse(req.url, true);
+
+        if (reqUrl.pathname === '/callback') {
+            // Extract tokens from hash (Supabase sends in hash fragment)
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(`
+                <html>
+                <head><meta charset="utf-8"><title>ContextAI Login</title></head>
+                <body style="font-family: system-ui; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; background: #0a0a0a; color: white;">
+                    <div style="text-align: center;">
+                        <h1>✅ Login Successful!</h1>
+                        <p>You can close this window and return to the terminal.</p>
+                        <script>
+                            // Extract hash params and send to parent
+                            const hash = window.location.hash.substring(1);
+                            const params = new URLSearchParams(hash);
+                            const accessToken = params.get('access_token');
+                            const refreshToken = params.get('refresh_token');
+                            
+                            if (accessToken) {
+                                fetch('/save-token?access_token=' + accessToken + '&refresh_token=' + (refreshToken || ''));
+                            }
+                        </script>
+                    </div>
+                </body>
+                </html>
+            `);
+        } else if (reqUrl.pathname === '/save-token') {
+            const accessToken = reqUrl.query.access_token;
+            const refreshToken = reqUrl.query.refresh_token;
+
+            if (accessToken) {
+                // Get user info
+                const supabase = createClient(supabaseUrl, supabaseKey);
+                const { data: { user }, error } = await supabase.auth.getUser(accessToken);
+
+                if (user && !error) {
+                    saveCredentials({
+                        access_token: accessToken,
+                        refresh_token: refreshToken,
+                        user_id: user.id,
+                        email: user.email,
+                        name: user.user_metadata?.full_name || user.email
+                    });
+
+                    console.log(chalk.green(`\n✅ Logged in as ${user.user_metadata?.full_name || user.email}!`));
+                    console.log(chalk.gray(`Credentials saved to ${CONFIG_FILE}`));
+                } else {
+                    console.error(chalk.red('❌ Failed to get user info'));
+                }
+            }
+
+            res.writeHead(200);
+            res.end('ok');
+
+            // Close server after a short delay
+            setTimeout(() => {
+                server.close();
+                process.exit(0);
+            }, 500);
+        } else {
+            res.writeHead(404);
+            res.end('Not found');
+        }
+    });
+
+    server.listen(PORT, async () => {
+        console.log(chalk.gray(`Callback server started on port ${PORT}`));
+
+        // Build OAuth URL
+        const authUrl = `${supabaseUrl}/auth/v1/authorize?provider=github&redirect_to=${encodeURIComponent(REDIRECT_URI)}`;
+
+        console.log(chalk.yellow('\n📱 Opening browser for GitHub login...'));
+        console.log(chalk.gray(`If browser doesn't open, visit: ${authUrl}\n`));
+
+        await open(authUrl);
+    });
+
+    // Timeout after 2 minutes
+    setTimeout(() => {
+        console.log(chalk.red('\n❌ Login timed out. Please try again.'));
+        server.close();
+        process.exit(1);
+    }, 120000);
+}
+
+export function whoami() {
+    const creds = loadCredentials();
+    if (creds) {
+        console.log(chalk.green(`Logged in as: ${creds.name || creds.email}`));
+        console.log(chalk.gray(`User ID: ${creds.user_id}`));
+    } else {
+        console.log(chalk.yellow('Not logged in. Run `contextai login` first.'));
+    }
+}
+
+export function logout() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        fs.unlinkSync(CONFIG_FILE);
+        console.log(chalk.green('✅ Logged out successfully.'));
+    } else {
+        console.log(chalk.yellow('Already logged out.'));
+    }
+}

package/src/actions/doctor.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import fetch from 'node-fetch';
+
+export async function doctor() {
+    console.log(chalk.bold('\n🏥 ContextAI Doctor\n'));
+
+    const checks = [
+        {
+            name: 'OS Info',
+            run: () => `${os.type()} ${os.release()} (${os.arch()})`,
+        },
+        {
+            name: 'Node.js Version',
+            run: () => {
+                const version = process.version;
+                const major = parseInt(version.substring(1).split('.')[0], 10);
+                if (major < 18) throw new Error(`Node.js ${version} is too old. Please upgrade to v18+.`);
+                return version;
+            }
+        },
+        {
+            name: 'Git Installed',
+            run: () => {
+                try {
+                    const gitVer = execSync('git --version').toString().trim();
+                    return gitVer;
+                } catch (e) {
+                    throw new Error('Git is not installed or not in PATH.');
+                }
+            }
+        },
+        {
+            name: 'Context Directory (.ai)',
+            run: () => {
+                const contextPath = path.join(process.cwd(), '.ai');
+                if (fs.existsSync(contextPath)) {
+                    return 'Found ✅';
+                } else {
+                    return 'Not found (Run `contextai init` to create one)';
+                }
+            }
+        },
+        {
+            name: 'Internet Connection',
+            run: async () => {
+                try {
+                    // simple fetch to google or registry
+                    await fetch('https://www.google.com', { method: 'HEAD' });
+                    return 'Online ✅';
+                } catch (e) {
+                    throw new Error('Offline ❌');
+                }
+            }
+        }
+    ];
+
+    for (const check of checks) {
+        process.stdout.write(`• Checking ${check.name}... `);
+        try {
+            const result = await check.run();
+            console.log(chalk.green(result));
+        } catch (error) {
+            console.log(chalk.red('FAILED'));
+            console.log(chalk.red(`  User Action: ${error.message}`));
+        }
+    }
+
+    console.log(chalk.gray('\nDiagnostic check complete.\n'));
+}

package/src/actions/init.js

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+export function init() {
+    console.log(chalk.green('Initializing Shared Brain...'));
+    const aiDir = path.join(process.cwd(), '.ai');
+    const ucpDir = path.join(aiDir, 'ucp');
+    const manifestPath = path.join(aiDir, 'context.json');
+    const bootPath = path.join(aiDir, 'boot.md');
+
+    if (fs.existsSync(aiDir)) {
+        // Check if it's legacy
+        if (!fs.existsSync(ucpDir) && fs.existsSync(path.join(aiDir, 'context'))) {
+            console.log(chalk.yellow('⚠️  Legacy .ai/ structure detected. Migration is recommended but not yet auto-implemented.'));
+            console.log(chalk.yellow('    Please start fresh or manually move contents to .ai/ucp/'));
+            return;
+        }
+
+        if (fs.existsSync(manifestPath)) {
+            console.log(chalk.yellow('⚠️  .ai/ already initialized.'));
+            return;
+        }
+    }
+
+    // 1. Create Directories (Namespace Isolation)
+    fs.mkdirSync(aiDir, { recursive: true });
+    fs.mkdirSync(path.join(ucpDir, 'context'), { recursive: true });
+
+    // 2. Create Traffic Cop (boot.md)
+    fs.writeFileSync(
+        bootPath,
+        `# AI Context Container\n\nThis project uses multiple context protocols.\n\n## Active Protocols\n1. **UCP** (Core OS): [Unified Context Protocol](./ucp/README.md)\n   - Use for: General Project Context, Workflows.\n`
+    );
+
+    // 3. Create Manifest (context.json)
+    const manifest = {
+        version: "1.0.0",
+        packages: {
+            "ucp": {
+                "type": "core",
+                "path": "./ucp"
+            }
+        }
+    };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    // 4. Seed UCP Basic Files
+    fs.writeFileSync(
+        path.join(ucpDir, 'README.md'),
+        '# Unified Context Protocol (UCP)\n\nThis directory contains the core operating system for your AI agent.'
+    );
+    fs.writeFileSync(
+        path.join(ucpDir, 'context', 'MASTER.md'),
+        '# Project Master Context\n\nPrimary context definition.'
+    );
+
+    console.log(chalk.green('✅ Successfully initialized Shared Brain (.ai/)!'));
+    console.log(chalk.gray('   - .ai/boot.md         (Traffic Cop)'));
+    console.log(chalk.gray('   - .ai/context.json    (Manifest)'));
+    console.log(chalk.gray('   - .ai/ucp/            (Core Protocol)'));
+}

package/src/actions/install.js

@@ -0,0 +1,268 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+import AdmZip from 'adm-zip';
+import os from 'os';
+import { copyRecursiveSync } from '../utils/fs.js';
+import ora from 'ora';
+import { supabase } from '../utils/supabase.js';
+
+// Load saved credentials
+function loadCredentials() {
+    const CONFIG_FILE = path.join(os.homedir(), '.contextai', 'credentials.json');
+    if (fs.existsSync(CONFIG_FILE)) {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+    return null;
+}
+
+export async function installPackage(packageSlug, options = {}) {
+    const spinner = ora(`Installing ${packageSlug}...`).start();
+
+    const aiDir = path.join(process.cwd(), '.ai');
+    const manifestPath = path.join(aiDir, 'context.json');
+
+    try {
+        // Check .ai exists
+        if (!fs.existsSync(manifestPath)) {
+            spinner.fail('.ai/ directory not found. Run `contextai init` first.');
+            process.exit(1);
+        }
+
+        // 1. Fetch pack from Supabase
+        spinner.text = `Fetching pack info for ${packageSlug}...`;
+
+        const { data: pack, error } = await supabase
+            .from('packs')
+            .select('*')
+            .eq('slug', packageSlug)
+            .eq('status', 'approved')
+            .maybeSingle();
+
+        if (error) {
+            spinner.fail('Error fetching pack from registry.');
+            console.error(chalk.gray(error.message));
+            process.exit(1);
+        }
+
+        if (!pack) {
+            // Try local registry as fallback for dev
+            spinner.text = 'Pack not in marketplace, checking local registry...';
+            const localPack = await tryLocalRegistry(packageSlug);
+            if (localPack) {
+                await installFromLocal(localPack, packageSlug, aiDir, manifestPath, spinner);
+                return;
+            }
+
+            spinner.fail(`Package "${packageSlug}" not found in marketplace.`);
+            console.log(chalk.gray('Check the slug or browse available packs at https://contextai.io/browse'));
+            process.exit(1);
+        }
+
+        spinner.text = `Found ${pack.title} by ${pack.creator_id ? 'verified creator' : 'community'}`;
+
+        // 2. Check if paid pack
+        if (pack.price && pack.price > 0) {
+            spinner.text = 'This is a paid pack. Checking purchase status...';
+
+            const creds = loadCredentials();
+            if (!creds) {
+                spinner.fail('This pack requires purchase.');
+                console.log(chalk.yellow('\n💡 Please login first:'));
+                console.log(chalk.cyan('   contextai login\n'));
+                console.log(chalk.gray(`Then purchase at: https://contextai.io/pack/${pack.slug}`));
+                process.exit(1);
+            }
+
+            // 3. Verify purchase
+            const { data: purchase } = await supabase
+                .from('purchases')
+                .select('id')
+                .eq('user_id', creds.user_id)
+                .eq('pack_id', pack.id)
+                .maybeSingle();
+
+            if (!purchase) {
+                spinner.fail('You have not purchased this pack.');
+                console.log(chalk.yellow(`\n💰 Price: ₹${pack.price}`));
+                console.log(chalk.cyan(`   Purchase at: https://contextai.io/pack/${pack.slug}\n`));
+                process.exit(1);
+            }
+
+            spinner.text = 'Purchase verified! Downloading...';
+        } else {
+            // Free Pack - Enforce Limits
+            const creds = loadCredentials();
+            if (creds) {
+                const { data: profile } = await supabase
+                    .from('profiles')
+                    .select('download_count')
+                    .eq('id', creds.user_id)
+                    .single();
+
+                // TODO: Un-comment when profiles table is backfilled
+                // if (profile && profile.download_count >= 5) {
+                //    spinner.fail('Free tier limit reached (5 downloads/mo).');
+                //    console.log(chalk.yellow('\n⚡ Upgrade to Pro for unlimited downloads:'));
+                //    console.log(chalk.cyan('   https://contextai.io/pricing\n'));
+                //    process.exit(1);
+                // }
+            }
+        }
+
+        // Track Download (user-level)
+        const creds = loadCredentials();
+        if (creds) {
+            await supabase.rpc('increment_download_count', { user_id: creds.user_id });
+        }
+
+        // Track Download (pack-level)
+        await supabase.rpc('increment_download', { pack_slug: packageSlug });
+
+        // 4. Resolve target directory
+        let targetDir = '';
+        if (packageSlug.startsWith('@')) {
+            const [scope, name] = packageSlug.substring(1).split('/');
+            targetDir = path.join(aiDir, '@' + scope, name);
+        } else {
+            targetDir = path.join(aiDir, packageSlug);
+        }
+
+        // 5. Download and extract
+        if (!pack.file_url) {
+            spinner.fail('Pack has no downloadable file.');
+            process.exit(1);
+        }
+
+        spinner.text = `Downloading from storage...`;
+
+        const response = await fetch(pack.file_url);
+        if (!response.ok) {
+            throw new Error(`Download failed: ${response.statusText}`);
+        }
+
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+
+        // Check if it's a zip or a single file
+        const isZip = pack.file_url.endsWith('.zip') || buffer[0] === 0x50; // PK signature
+
+        if (isZip) {
+            const zip = new AdmZip(buffer);
+            const tempDir = path.join(os.tmpdir(), `contextai-${Date.now()}`);
+            zip.extractAllTo(tempDir, true);
+
+            // Find actual root
+            const items = fs.readdirSync(tempDir);
+            const rootItem = items.find(i => fs.statSync(path.join(tempDir, i)).isDirectory());
+            const sourceDir = rootItem ? path.join(tempDir, rootItem) : tempDir;
+
+            spinner.text = 'Injecting Verified Context...';
+            copyRecursiveSync(sourceDir, targetDir);
+
+            // Cleanup
+            try { fs.rmSync(tempDir, { recursive: true, force: true }); } catch (e) { }
+        } else {
+            // Single file (like .cursorrules)
+            if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+            }
+            const filename = path.basename(pack.file_url);
+            fs.writeFileSync(path.join(targetDir, filename), buffer);
+        }
+
+        // 6. Update manifest
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+        manifest.packages = manifest.packages || {};
+        manifest.packages[packageSlug] = {
+            type: 'community',
+            path: `./${path.relative(aiDir, targetDir).replace(/\\/g, '/')}`,
+            installedAt: new Date().toISOString(),
+            version: pack.version || '1.0.0'
+        };
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+        // 7. Update README
+        const readmePath = path.join(aiDir, 'README.md');
+        if (fs.existsSync(readmePath)) {
+            let readme = fs.readFileSync(readmePath, 'utf8');
+            const entryLine = `**${packageSlug}**: [View Context](${manifest.packages[packageSlug].path}/README.md)`;
+            if (!readme.includes(packageSlug)) {
+                if (readme.includes('## Active Protocols')) {
+                    readme += `\n- ${entryLine}`;
+                } else {
+                    readme += `\n\n## Installed Packages\n- ${entryLine}`;
+                }
+                fs.writeFileSync(readmePath, readme);
+            }
+        }
+
+        spinner.succeed(`Successfully installed ${pack.title}!`);
+        console.log(chalk.gray(`   Context Pack installed to: ${targetDir}`));
+        if (pack.price > 0) {
+            console.log(chalk.green('   ✓ Paid pack - thank you for your purchase!'));
+        }
+
+    } catch (err) {
+        spinner.fail('Installation failed:');
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+}
+
+// Fallback for local development registry
+async function tryLocalRegistry(packageName) {
+    let registryPath = path.resolve(process.cwd(), 'ucp-registry');
+    if (!fs.existsSync(registryPath)) {
+        registryPath = path.resolve(process.cwd(), '..', 'ucp-registry');
+    }
+
+    if (fs.existsSync(path.join(registryPath, 'index.json'))) {
+        try {
+            const registry = JSON.parse(fs.readFileSync(path.join(registryPath, 'index.json'), 'utf8'));
+            const pkg = registry.packages[packageName];
+            if (pkg) {
+                return { ...pkg, registryPath };
+            }
+        } catch (e) {
+            // Ignore
+        }
+    }
+    return null;
+}
+
+async function installFromLocal(localPkg, packageName, aiDir, manifestPath, spinner) {
+    spinner.text = `Installing ${packageName} from local registry...`;
+
+    let targetDir = '';
+    if (localPkg.type === 'core') {
+        targetDir = path.join(aiDir, 'ucp');
+    } else if (packageName.startsWith('@')) {
+        const [scope, name] = packageName.substring(1).split('/');
+        targetDir = path.join(aiDir, '@' + scope, name);
+    } else {
+        targetDir = path.join(aiDir, packageName);
+    }
+
+    const sourceDir = path.join(localPkg.registryPath, localPkg.path);
+    if (!fs.existsSync(sourceDir)) {
+        spinner.fail(`Package content missing at ${sourceDir}`);
+        process.exit(1);
+    }
+
+    copyRecursiveSync(sourceDir, targetDir);
+
+    // Update manifest
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    manifest.packages = manifest.packages || {};
+    manifest.packages[packageName] = {
+        type: localPkg.type,
+        path: `./${path.relative(aiDir, targetDir).replace(/\\/g, '/')}`,
+        installedAt: new Date().toISOString()
+    };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+    spinner.succeed(`Successfully installed ${packageName} from local registry!`);
+    console.log(chalk.gray(`   Location: ${targetDir}`));
+}

package/src/actions/publish.js

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+
+export function publish() {
+    console.log(chalk.blue('📦 Validating package for publication...'));
+
+    const cwd = process.cwd();
+    // Validation 1: Must have README.md
+    if (!fs.existsSync(path.join(cwd, 'README.md'))) {
+        console.error(chalk.red('❌ Missing README.md'));
+        console.error(chalk.gray('   Please create a README.md describing your context package.'));
+        process.exit(1);
+    }
+
+    // Validation 2: Must have context/ directory or bin/ directory
+    // A valid package must have substantial content.
+    const hasContext = fs.existsSync(path.join(cwd, 'context'));
+    const hasBin = fs.existsSync(path.join(cwd, 'bin'));
+
+    if (!hasContext && !hasBin) {
+        console.error(chalk.red('❌ Invalid Package Structure'));
+        console.error(chalk.gray('   Must contain a "context/" or "bin/" directory.'));
+        process.exit(1);
+    }
+
+    console.log(chalk.green('✅ Package validation passed!'));
+    console.log('');
+    console.log('To publish your package:');
+    console.log('1. Push this directory to a public GitHub repository.');
+    console.log('2. Submit a Pull Request to the ContextAI Registry:');
+    console.log(chalk.blue('   https://github.com/contextai/registry'));
+    console.log('');
+    console.log('Add your package to index.json:');
+    console.log(chalk.gray(`
+    "your-package-name": {
+        "type": "feature",
+        "url": "https://github.com/your-username/your-repo/archive/refs/heads/main.zip",
+        "description": "Description of your package"
+    }
+        `));
+}

package/src/utils/fs.js

@@ -0,0 +1,27 @@
+import fs from 'fs';
+import path from 'path';
+import { smartMergeFile } from './merge.js';
+
+export function copyRecursiveSync(src, dest) {
+    const exists = fs.existsSync(src);
+    const stats = exists && fs.statSync(src);
+    const isDirectory = exists && stats.isDirectory();
+
+    if (isDirectory) {
+        if (!fs.existsSync(dest)) fs.mkdirSync(dest, { recursive: true });
+        fs.readdirSync(src).forEach(childItemName => {
+            copyRecursiveSync(path.join(src, childItemName), path.join(dest, childItemName));
+        });
+    } else {
+        const ext = path.extname(src);
+
+        // Only smart merge specific types that accept utf8 content
+        if (['.json', '.md'].includes(ext)) {
+            const content = fs.readFileSync(src, 'utf8');
+            smartMergeFile(dest, content, ext);
+        } else {
+            // Binary safe copy
+            fs.copyFileSync(src, dest);
+        }
+    }
+}

package/src/utils/merge.js

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Deep merges two objects.
+ * @param {Object} target 
+ * @param {Object} source 
+ * @returns {Object}
+ */
+function deepMerge(target, source) {
+    if (typeof target !== 'object' || target === null) return source;
+    if (typeof source !== 'object' || source === null) return target;
+
+    const output = { ...target };
+
+    Object.keys(source).forEach(key => {
+        if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
+            if (!(key in target)) {
+                Object.assign(output, { [key]: source[key] });
+            } else {
+                output[key] = deepMerge(target[key], source[key]);
+            }
+        } else {
+            Object.assign(output, { [key]: source[key] });
+        }
+    });
+
+    return output;
+}
+
+/**
+ * Merges two Markdown strings.
+ * Appends the source content to the target content if it's not already present.
+ * Uses a heuristic based on checking for unique headers or content blocks if possible.
+ * For MVP: Naive append with check.
+ * 
+ * @param {string} targetContent 
+ * @param {string} sourceContent 
+ * @returns {string}
+ */
+function mergeMarkdown(targetContent, sourceContent) {
+    // Normalize newlines
+    const normalizedTarget = targetContent.replace(/\r\n/g, '\n');
+    const normalizedSource = sourceContent.replace(/\r\n/g, '\n');
+
+    // Simple duplicate check: if the source content (trimmed) is fully inside target, skip or duplicate?
+    // Better: Check for key headers.
+    // MVP Strategy: Just append if not exactly present. 
+    // Ideally we want to prevent adding the same "Dependency" twice.
+
+    if (normalizedTarget.includes(normalizedSource.trim())) {
+        return targetContent;
+    }
+
+    // Add a separator if needed
+    const sep = normalizedTarget.endsWith('\n') ? '\n' : '\n\n';
+    return targetContent + sep + sourceContent;
+}
+
+/**
+ * Smart Merge File
+ * Decides how to merge based on file extension.
+ * @param {string} targetPath - Path to the existing file
+ * @param {string} sourceContent - Content to merge in (string or buffer)
+ * @param {string} fileExt - Extension (e.g., .json, .md)
+ */
+export function smartMergeFile(targetPath, sourceContent, fileExt) {
+    if (!fs.existsSync(targetPath)) {
+        fs.writeFileSync(targetPath, sourceContent);
+        return;
+    }
+
+    const currentContent = fs.readFileSync(targetPath, 'utf8');
+
+    if (fileExt === '.json') {
+        try {
+            const targetObj = JSON.parse(currentContent);
+            const sourceObj = JSON.parse(sourceContent);
+            const merged = deepMerge(targetObj, sourceObj);
+            fs.writeFileSync(targetPath, JSON.stringify(merged, null, 2));
+        } catch (e) {
+            console.warn(`Failed to merge JSON for ${targetPath}. Overwriting fallback skipped (safe mode).`);
+            // fs.writeFileSync(targetPath, sourceContent); // Dangerous fallback
+        }
+    } else if (fileExt === '.md') {
+        const merged = mergeMarkdown(currentContent, sourceContent);
+        fs.writeFileSync(targetPath, merged);
+    } else {
+        // Text/Binary: Overwrite (Standard behavior for "install")
+        // or Append?
+        // Default Installing typically overwrites files unless they are config.
+        // For ContextAI: "Immutable Engine, Mutable Data"
+        // If it's in `bin/`, overwrite. If `context/`, maybe append?
+        // For now: Overwrite.
+        fs.writeFileSync(targetPath, sourceContent);
+    }
+}

package/src/utils/supabase.js

@@ -0,0 +1,37 @@
+import { createClient } from '@supabase/supabase-js';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Load .env file from CLI directory or parent
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const envPaths = [
+    path.join(__dirname, '..', '..', '.env'),  // cli/.env
+    path.join(__dirname, '..', '..', '..', '.env'),  // parent contextai/.env
+    path.join(process.cwd(), '.env')  // current working directory
+];
+
+for (const envPath of envPaths) {
+    if (fs.existsSync(envPath)) {
+        const envConfig = fs.readFileSync(envPath, 'utf8');
+        envConfig.split('\n').forEach(line => {
+            const [key, ...valueParts] = line.split('=');
+            const value = valueParts.join('='); // Handle = in values
+            if (key && value && !process.env[key.trim()]) {
+                process.env[key.trim()] = value.trim();
+            }
+        });
+        break;
+    }
+}
+
+const SUPABASE_URL = process.env.VITE_SUPABASE_URL;
+const SUPABASE_KEY = process.env.VITE_SUPABASE_ANON_KEY;
+
+if (!SUPABASE_URL || !SUPABASE_KEY) {
+    console.error('Error: VITE_SUPABASE_URL and VITE_SUPABASE_ANON_KEY must be set.');
+    console.error('Create a .env file or set environment variables.');
+    process.exit(1);
+}
+
+export const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);