@josfox/jos 3.1.1 → 4.0.0

package/src/commands/get.js

@@ -0,0 +1,245 @@
+/**
+ * JOS GET Command - Fetch .jos packages from repos
+ * Architecture similar to npm/brew/apt but offline-first
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const crypto = require('crypto');
+
+// AURORA colors
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    purple: '\x1b[38;5;135m', magenta: '\x1b[38;5;198m', cyan: '\x1b[38;5;51m',
+    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m', gray: '\x1b[38;5;245m',
+    white: '\x1b[38;5;255m', yellow: '\x1b[38;5;220m'
+};
+
+// Default repos configuration
+const DEFAULT_REPOS = {
+    default: 'https://registry.josfox.ai',
+    local: '~/.jos/artifacts'
+};
+
+function getReposConfig(home) {
+    const reposPath = path.join(home, 'repos.json');
+    if (fs.existsSync(reposPath)) {
+        return { ...DEFAULT_REPOS, ...JSON.parse(fs.readFileSync(reposPath)) };
+    }
+    return DEFAULT_REPOS;
+}
+
+function computeIntegrity(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+// Lock file management
+function getLockPath(home) {
+    return path.join(home, 'lock.json');
+}
+
+function loadLock(home) {
+    const lockPath = getLockPath(home);
+    if (fs.existsSync(lockPath)) {
+        return JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    }
+    return { locked: null, packages: {} };
+}
+
+function saveLock(home, lock) {
+    const lockPath = getLockPath(home);
+    lock.locked = new Date().toISOString();
+    fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+}
+
+function updateLock(home, pkgName, version, integrity) {
+    const lock = loadLock(home);
+    lock.packages[pkgName] = { version, integrity: `sha256-${integrity}` };
+    saveLock(home, lock);
+}
+
+// Parse package reference: "pkg", "repo:pkg", "./path", "http://..."
+function parsePackageRef(ref) {
+    // URL
+    if (ref.startsWith('http://') || ref.startsWith('https://')) {
+        return { type: 'url', url: ref };
+    }
+    // Local path
+    if (ref.startsWith('./') || ref.startsWith('/') || ref.startsWith('~')) {
+        return { type: 'local', path: ref };
+    }
+    // Named repo: "myrepo:package"
+    if (ref.includes(':')) {
+        const [repo, pkg] = ref.split(':');
+        return { type: 'repo', repo, package: pkg };
+    }
+    // Default: package name
+    return { type: 'default', package: ref };
+}
+
+// Fetch from URL
+function fetchUrl(url) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? https : http;
+        protocol.get(url, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                return fetchUrl(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode !== 200) {
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => resolve(data));
+        }).on('error', reject);
+    });
+}
+
+exports.execute = async (args, home) => {
+    const target = args[0];
+    const fromRepo = args.find((a, i) => args[i - 1] === '--from');
+    const showHelp = args.includes('--help') || args.includes('-h');
+
+    if (showHelp || !target) {
+        console.log(`
+${C.cyan}${C.bold}JOS GET${C.reset} - Fetch .jos packages
+
+${C.white}Usage:${C.reset} jos get <package> [options]
+
+${C.white}Package formats:${C.reset}
+  jos get hello              ${C.dim}# From default registry${C.reset}
+  jos get ./my-package       ${C.dim}# From local folder${C.reset}
+  jos get myrepo:package     ${C.dim}# From named repo${C.reset}
+  jos get http://host/p.jos  ${C.dim}# From URL${C.reset}
+
+${C.white}Options:${C.reset}
+  --from <host>   Override source (e.g., --from 192.168.1.10:1111)
+  --help, -h      Show this help
+
+${C.white}Configuration:${C.reset}
+  Repos defined in: ~/.jos/repos.json
+  
+${C.white}Example repos.json:${C.reset}
+  {
+    "default": "https://registry.josfox.ai",
+    "local": "~/.jos/artifacts",
+    "myrepo": "http://192.168.1.10:1111"
+  }
+`);
+        return;
+    }
+
+    console.log(`\n${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+    console.log(`${C.cyan}${C.bold}JOS GET${C.reset} // ${C.gray}Package Manager${C.reset}`);
+    console.log(`${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}\n`);
+
+    const repos = getReposConfig(home);
+    const artifactsDir = path.join(home, 'artifacts');
+    if (!fs.existsSync(artifactsDir)) fs.mkdirSync(artifactsDir, { recursive: true });
+
+    // Parse reference
+    let ref = parsePackageRef(target);
+
+    // Override with --from
+    if (fromRepo) {
+        const host = fromRepo.includes(':') ? fromRepo : `${fromRepo}:1111`;
+        ref = { type: 'url', url: `http://${host}/${target}.jos` };
+        console.log(`${C.white}📡 Source:${C.reset} ${host}`);
+    }
+
+    console.log(`${C.white}📦 Package:${C.reset} ${target}`);
+    console.log(`${C.white}📁 Destination:${C.reset} ${artifactsDir}`);
+
+    let content, sourcePath;
+
+    try {
+        switch (ref.type) {
+            case 'local':
+                // Local folder/file
+                sourcePath = ref.path.replace('~', process.env.HOME);
+                if (!sourcePath.endsWith('.jos')) sourcePath += '.jos';
+                if (!fs.existsSync(sourcePath)) throw new Error(`Not found: ${sourcePath}`);
+                content = fs.readFileSync(sourcePath, 'utf8');
+                console.log(`${C.green}✓ Found locally:${C.reset} ${sourcePath}`);
+                break;
+
+            case 'url':
+                // Direct URL
+                console.log(`${C.dim}⏳ Fetching from URL...${C.reset}`);
+                content = await fetchUrl(ref.url);
+                console.log(`${C.green}✓ Downloaded from:${C.reset} ${ref.url}`);
+                break;
+
+            case 'repo':
+                // Named repo
+                const repoUrl = repos[ref.repo];
+                if (!repoUrl) throw new Error(`Unknown repo: ${ref.repo}`);
+                const pkgUrl = repoUrl.startsWith('http')
+                    ? `${repoUrl}/${ref.package}.jos`
+                    : path.join(repoUrl.replace('~', process.env.HOME), `${ref.package}.jos`);
+
+                if (pkgUrl.startsWith('http')) {
+                    console.log(`${C.dim}⏳ Fetching from ${ref.repo}...${C.reset}`);
+                    content = await fetchUrl(pkgUrl);
+                } else {
+                    if (!fs.existsSync(pkgUrl)) throw new Error(`Not found: ${pkgUrl}`);
+                    content = fs.readFileSync(pkgUrl, 'utf8');
+                }
+                console.log(`${C.green}✓ Found in ${ref.repo}:${C.reset} ${ref.package}`);
+                break;
+
+            case 'default':
+                // Try local first, then default registry
+                const localPath = path.join(artifactsDir, `${ref.package}.jos`);
+                if (fs.existsSync(localPath)) {
+                    console.log(`${C.green}✓ Already cached:${C.reset} ${localPath}`);
+                    return;
+                }
+
+                // Try default registry
+                if (repos.default && repos.default.startsWith('http')) {
+                    console.log(`${C.dim}⏳ Fetching from registry...${C.reset}`);
+                    try {
+                        content = await fetchUrl(`${repos.default}/${ref.package}.jos`);
+                        console.log(`${C.green}✓ Downloaded:${C.reset} ${ref.package}`);
+                    } catch (e) {
+                        throw new Error(`Package not found: ${ref.package}`);
+                    }
+                } else {
+                    throw new Error(`Package not found: ${ref.package}`);
+                }
+                break;
+        }
+
+        // Validate JSON
+        let artifact;
+        try {
+            artifact = JSON.parse(content);
+        } catch (e) {
+            throw new Error('Invalid .jos file (not valid JSON)');
+        }
+
+        // Compute integrity
+        const integrity = computeIntegrity(content);
+        console.log(`${C.white}🔐 Integrity:${C.reset} ${C.green}${integrity.substring(0, 16)}...${C.reset}`);
+
+        // Save artifact
+        const pkgName = artifact.meta?.name || artifact.name || target.replace(/[^a-z0-9]/gi, '_');
+        const pkgVersion = artifact.meta?.version || artifact.orchestration_contract?.version || '1.0.0';
+        const destPath = path.join(artifactsDir, `${pkgName}.jos`);
+        fs.writeFileSync(destPath, content);
+
+        // Update lock file
+        updateLock(home, pkgName, pkgVersion, integrity);
+        console.log(`${C.dim}📋 Lock file updated${C.reset}`);
+
+        console.log(`\n${C.green}✓ Saved to:${C.reset} ${destPath}`);
+        console.log(`${C.dim}  Run with: jos run ${pkgName}.jos${C.reset}\n`);
+
+    } catch (e) {
+        console.log(`\n${C.red}✖ Error:${C.reset} ${e.message}\n`);
+        process.exit(1);
+    }
+};

package/src/commands/repo.js

@@ -0,0 +1,139 @@
+/**
+ * JOS REPO Command - Manage package repositories
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// AURORA colors
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    purple: '\x1b[38;5;135m', magenta: '\x1b[38;5;198m', cyan: '\x1b[38;5;51m',
+    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m', gray: '\x1b[38;5;245m',
+    white: '\x1b[38;5;255m', yellow: '\x1b[38;5;220m'
+};
+
+const DEFAULT_REPOS = {
+    default: 'https://registry.josfox.ai',
+    local: '~/.jos/artifacts'
+};
+
+function getReposPath(home) {
+    return path.join(home, 'repos.json');
+}
+
+function loadRepos(home) {
+    const reposPath = getReposPath(home);
+    if (fs.existsSync(reposPath)) {
+        return { ...DEFAULT_REPOS, ...JSON.parse(fs.readFileSync(reposPath, 'utf8')) };
+    }
+    return { ...DEFAULT_REPOS };
+}
+
+function saveRepos(home, repos) {
+    const reposPath = getReposPath(home);
+    fs.writeFileSync(reposPath, JSON.stringify(repos, null, 2));
+}
+
+exports.execute = async (args, home) => {
+    const action = args[0];
+    const name = args[1];
+    const url = args[2];
+    const showHelp = args.includes('--help') || args.includes('-h');
+
+    if (showHelp || !action) {
+        console.log(`
+${C.cyan}${C.bold}JOS REPO${C.reset} - Manage package repositories
+
+${C.white}Usage:${C.reset} jos repo <action> [name] [url]
+
+${C.white}Actions:${C.reset}
+  list                 Show all configured repos
+  add <name> <url>     Add a new repository
+  remove <name>        Remove a repository
+  default <name>       Set default repository
+
+${C.white}Examples:${C.reset}
+  jos repo list
+  jos repo add myserver http://192.168.1.10:1111
+  jos repo add company https://artifacts.company.com
+  jos repo default myserver
+  jos repo remove myserver
+
+${C.white}Using repos:${C.reset}
+  jos get myserver:package-name
+  jos get package --from 192.168.1.10
+`);
+        return;
+    }
+
+    const repos = loadRepos(home);
+
+    switch (action) {
+        case 'list':
+            console.log(`\n${C.cyan}${C.bold}📦 Configured Repositories${C.reset}\n`);
+            Object.entries(repos).forEach(([name, url]) => {
+                const isDefault = name === 'default';
+                const isLocal = name === 'local';
+                console.log(`  ${C.white}${name}${C.reset}`);
+                console.log(`    ${C.gray}${url}${C.reset}`);
+                if (isDefault) console.log(`    ${C.green}★ Default registry${C.reset}`);
+                if (isLocal) console.log(`    ${C.cyan}📁 Local artifacts${C.reset}`);
+                console.log();
+            });
+            console.log(`${C.dim}Config: ~/.jos/repos.json${C.reset}\n`);
+            break;
+
+        case 'add':
+            if (!name || !url) {
+                console.log(`${C.red}✖ Usage: jos repo add <name> <url>${C.reset}`);
+                process.exit(1);
+            }
+            if (repos[name] && name !== 'default' && name !== 'local') {
+                console.log(`${C.yellow}⚠ Repository '${name}' already exists. Updating...${C.reset}`);
+            }
+            repos[name] = url;
+            saveRepos(home, repos);
+            console.log(`${C.green}✓ Repository '${name}' added: ${url}${C.reset}`);
+            console.log(`${C.dim}  Use: jos get ${name}:package-name${C.reset}`);
+            break;
+
+        case 'remove':
+        case 'rm':
+            if (!name) {
+                console.log(`${C.red}✖ Usage: jos repo remove <name>${C.reset}`);
+                process.exit(1);
+            }
+            if (name === 'default' || name === 'local') {
+                console.log(`${C.red}✖ Cannot remove built-in repository '${name}'${C.reset}`);
+                process.exit(1);
+            }
+            if (!repos[name]) {
+                console.log(`${C.yellow}⚠ Repository '${name}' not found${C.reset}`);
+                process.exit(1);
+            }
+            delete repos[name];
+            saveRepos(home, repos);
+            console.log(`${C.green}✓ Repository '${name}' removed${C.reset}`);
+            break;
+
+        case 'default':
+            if (!name) {
+                console.log(`${C.white}Current default: ${repos.default}${C.reset}`);
+                return;
+            }
+            if (!repos[name] && !name.startsWith('http')) {
+                console.log(`${C.red}✖ Repository '${name}' not found${C.reset}`);
+                process.exit(1);
+            }
+            repos.default = repos[name] || name;
+            saveRepos(home, repos);
+            console.log(`${C.green}✓ Default repository set to: ${repos.default}${C.reset}`);
+            break;
+
+        default:
+            console.log(`${C.red}✖ Unknown action: ${action}${C.reset}`);
+            console.log(`${C.dim}Run 'jos repo --help' for usage${C.reset}`);
+            process.exit(1);
+    }
+};

package/src/commands/run.js

@@ -0,0 +1,225 @@
+/**
+ * JOS RUN Command - Execute .jos artifacts
+ * Complies with JOSFOXAI MAGIC contract
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+const crypto = require('crypto');
+
+// AURORA colors
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    purple: '\x1b[38;5;135m', magenta: '\x1b[38;5;198m', cyan: '\x1b[38;5;51m',
+    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m', gray: '\x1b[38;5;245m',
+    white: '\x1b[38;5;255m', yellow: '\x1b[38;5;220m'
+};
+
+// Compute SHA-256 integrity
+function computeIntegrity(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+
+// Validate JOSFOXAI MAGIC contract (flexible for different schemas)
+function validateMagic(artifact) {
+    const errors = [];
+    const warnings = [];
+
+    // MAGIC components (Intention) - flexible detection
+    const hasMeta = artifact.meta || artifact._josfox || artifact.jos_schema;
+    const hasIntention = artifact.intention || artifact.meta?.intention ||
+        artifact.description || artifact._josfox?.description;
+
+    if (!hasMeta) warnings.push('Recommended: meta or _josfox');
+    if (!hasIntention) warnings.push('Recommended: intention or description');
+
+    // JOSFOXAI components (Execution) - at least one required
+    const hasExecution = artifact.flow || artifact.tasks || artifact.pipelines ||
+        artifact.jos || artifact.shell;
+    if (!hasExecution) errors.push('Missing: execution (flow/tasks/pipelines/shell)');
+
+    return { valid: errors.length === 0, errors, warnings };
+}
+
+exports.execute = async (args, home) => {
+    const target = args[0];
+    const dryRun = args.includes('--dry-run');
+    const showHelp = args.includes('--help') || args.includes('-h');
+
+    if (showHelp || !target) {
+        console.log(`
+${C.cyan}${C.bold}JOS RUN${C.reset} - Execute .jos artifacts
+
+${C.white}Usage:${C.reset} jos run <file.jos> [options]
+
+${C.white}Options:${C.reset}
+  --dry-run     Validate and show plan without executing
+  --task <name> Run specific task only
+  --help, -h    Show this help
+
+${C.white}Examples:${C.reset}
+  jos run hello.jos
+  jos run ./my-artifact.jos --dry-run
+  jos run artifact.jos --task build
+`);
+        return;
+    }
+
+    // Resolve path
+    let artifactPath = target;
+    if (!fs.existsSync(artifactPath)) {
+        artifactPath = path.join(home, 'artifacts', target);
+        if (!fs.existsSync(artifactPath)) {
+            artifactPath = path.join(process.cwd(), target);
+        }
+    }
+
+    if (!fs.existsSync(artifactPath)) {
+        console.log(`${C.red}✖ Artifact not found:${C.reset} ${target}`);
+        console.log(`${C.dim}  Searched: ./, ~/.jos/artifacts/${C.reset}`);
+        process.exit(1);
+    }
+
+    console.log(`\n${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+    console.log(`${C.cyan}${C.bold}JOS RUN${C.reset} // ${C.gray}JOSFOXAI MAGIC Runtime${C.reset}`);
+    console.log(`${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}\n`);
+
+    // Load artifact
+    const content = fs.readFileSync(artifactPath, 'utf8');
+    const integrity = computeIntegrity(content);
+    let artifact;
+
+    try {
+        artifact = JSON.parse(content);
+    } catch (e) {
+        console.log(`${C.red}✖ Invalid JSON:${C.reset} ${e.message}`);
+        process.exit(1);
+    }
+
+    // Display metadata
+    console.log(`${C.white}📦 Artifact:${C.reset} ${artifact.meta?.name || artifact.name || path.basename(artifactPath)}`);
+    console.log(`${C.white}📄 File:${C.reset} ${artifactPath}`);
+    console.log(`${C.white}🔐 Integrity:${C.reset} ${C.green}${integrity.substring(0, 16)}...${C.reset}`);
+
+    // Validate MAGIC
+    const validation = validateMagic(artifact);
+    if (!validation.valid) {
+        console.log(`\n${C.red}✖ MAGIC Validation Failed:${C.reset}`);
+        validation.errors.forEach(e => console.log(`  ${C.red}•${C.reset} ${e}`));
+        process.exit(1);
+    }
+    console.log(`${C.white}✓ MAGIC:${C.reset} ${C.green}Valid${C.reset}`);
+
+    // Show intention
+    const intention = artifact.intention?.objective || artifact.meta?.intention || 'No intention defined';
+    console.log(`${C.white}🎯 Intention:${C.reset} ${intention}`);
+
+    // Check guardrails
+    if (artifact.guardrails?.avoid?.length > 0) {
+        console.log(`${C.white}🛡️ Guardrails:${C.reset} ${artifact.guardrails.avoid.join(', ')}`);
+    }
+
+    // Determine execution mode
+    const taskName = args.find((a, i) => args[i - 1] === '--task');
+
+    console.log(`\n${C.cyan}▶ Execution Plan:${C.reset}`);
+
+    // Execute based on artifact type
+    if (artifact.pipelines && !taskName) {
+        // Pipeline mode
+        const pipelineNames = Object.keys(artifact.pipelines);
+        console.log(`  ${C.dim}Mode: Pipeline${C.reset}`);
+        pipelineNames.forEach(name => {
+            const pipeline = artifact.pipelines[name];
+            console.log(`  ${C.cyan}→${C.reset} ${name}: ${pipeline.steps?.length || 0} steps`);
+        });
+
+        if (dryRun) {
+            console.log(`\n${C.yellow}⚡ Dry run - no execution${C.reset}`);
+            return;
+        }
+
+        // Execute first pipeline
+        const firstPipeline = pipelineNames[0];
+        await executePipeline(artifact, firstPipeline, artifact.pipelines[firstPipeline]);
+
+    } else if (artifact.tasks) {
+        // Task mode
+        const taskNames = taskName ? [taskName] : Object.keys(artifact.tasks);
+        console.log(`  ${C.dim}Mode: Tasks${C.reset}`);
+        taskNames.forEach(name => {
+            const task = artifact.tasks[name];
+            console.log(`  ${C.cyan}→${C.reset} ${name}: ${task.description || ''}`);
+        });
+
+        if (dryRun) {
+            console.log(`\n${C.yellow}⚡ Dry run - no execution${C.reset}`);
+            return;
+        }
+
+        // Execute tasks
+        for (const name of taskNames) {
+            await executeTask(name, artifact.tasks[name]);
+        }
+
+    } else if (artifact.flow?.steps) {
+        // Simple flow mode
+        console.log(`  ${C.dim}Mode: Flow${C.reset}`);
+        artifact.flow.steps.forEach((step, i) => {
+            console.log(`  ${C.cyan}${i + 1}.${C.reset} ${step}`);
+        });
+
+        if (dryRun) {
+            console.log(`\n${C.yellow}⚡ Dry run - no execution${C.reset}`);
+            return;
+        }
+
+        // Execute steps
+        for (const step of artifact.flow.steps) {
+            executeStep(step);
+        }
+    }
+
+    console.log(`\n${C.green}✓ Execution complete${C.reset}\n`);
+};
+
+async function executePipeline(artifact, name, pipeline) {
+    console.log(`\n${C.purple}▶ Running pipeline: ${name}${C.reset}\n`);
+
+    for (const stepRef of pipeline.steps || []) {
+        // Parse step reference (e.g., "tasks.build")
+        const [type, taskName] = stepRef.split('.');
+
+        if (type === 'tasks' && artifact.tasks[taskName]) {
+            await executeTask(taskName, artifact.tasks[taskName]);
+        } else {
+            console.log(`  ${C.yellow}⚠ Unknown step: ${stepRef}${C.reset}`);
+        }
+    }
+}
+
+async function executeTask(name, task) {
+    console.log(`\n${C.cyan}▶ Task: ${name}${C.reset}`);
+    if (task.description) console.log(`  ${C.dim}${task.description}${C.reset}`);
+
+    if (task.shell && Array.isArray(task.shell)) {
+        const script = task.shell.join('\n');
+        try {
+            execSync(script, { stdio: 'inherit', shell: '/bin/bash' });
+            console.log(`  ${C.green}✓ Task complete${C.reset}`);
+        } catch (e) {
+            console.log(`  ${C.red}✖ Task failed: ${e.message}${C.reset}`);
+            throw e;
+        }
+    }
+}
+
+function executeStep(step) {
+    console.log(`  ${C.cyan}▶${C.reset} ${step}`);
+    try {
+        execSync(step, { stdio: 'inherit', shell: true });
+    } catch (e) {
+        console.log(`  ${C.red}✖ Step failed${C.reset}`);
+    }
+}