@josfox/jos 4.0.7 → 4.1.0

package/src/commands/validate.js

@@ -1,190 +1,194 @@
-/**
- * JOS VALIDATE Command - Validate .jos artifacts
- * Checks schema, required keys, and integrity
- * Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)
- */
-
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-
-const C = {
-    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
-    purple: '\x1b[38;5;135m', cyan: '\x1b[38;5;51m',
-    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m',
-    yellow: '\x1b[38;5;220m', gray: '\x1b[38;5;245m'
-};
-
-// Witness Logging
-function logWitness(home, eventType, data) {
-    const runId = global.JOS_VALIDATE_ID || new Date().toISOString().replace(/[:.]/g, '-');
-    global.JOS_VALIDATE_ID = runId;
-
-    const runDir = path.join(home, 'runs', runId);
-    if (!fs.existsSync(runDir)) fs.mkdirSync(runDir, { recursive: true });
-
-    const event = {
-        timestamp: new Date().toISOString(),
-        type: `validate:${eventType}`,
-        ...data
-    };
-
-    fs.appendFileSync(path.join(runDir, 'events.jsonl'), JSON.stringify(event) + '\n');
-}
-
-// Required keys for JOSFOXAI + MAGIC compliance
-const JOSFOXAI_KEYS = ['jos', 'orchestration_contract', 'security', 'files', 'orchestration', 'x_run_params', 'adaptive_ai', 'id_jos'];
-const MAGIC_KEYS = ['meta', 'artifacts', 'guardrails', 'intention', 'capabilities'];
-const ALL_REQUIRED_KEYS = [...JOSFOXAI_KEYS, ...MAGIC_KEYS];
-
-exports.execute = async (args, home) => {
-    const target = args[0];
-    const insecure = args.includes('--insecure');
-    const verbose = args.includes('--verbose') || args.includes('-v');
-
-    if (!target || args.includes('--help')) {
-        console.log(`
-${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
-${C.bold}JOS VALIDATE${C.reset} // Validate .jos artifacts
-${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
-
-${C.bold}Usage:${C.reset}
-  jos validate <file.jos> [options]
-
-${C.bold}Options:${C.reset}
-  --insecure    Skip integrity verification
-  --verbose     Show detailed validation information
-
-${C.bold}Validates:${C.reset}
-  1. JSON syntax
-  2. JOSFOXAI keys: ${JOSFOXAI_KEYS.join(', ')}
-  3. MAGIC keys: ${MAGIC_KEYS.join(', ')}
-  4. Integrity manifest (unless --insecure)
-`);
-        return;
-    }
-
-    console.log(`\n${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
-    console.log(`${C.bold}JOS VALIDATE${C.reset} // ${C.gray}Format v0.0.7 — Spec v0.1.0 (Alpha)${C.reset}`);
-    console.log(`${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
-    console.log(`\n${C.cyan}📋 Artifact:${C.reset} ${target}`);
-
-    logWitness(home, 'start', { artifact: target });
-
-    let allPassed = true;
-    const results = [];
-
-    // 1. JSON Syntax Check
-    let content, artifact;
-    try {
-        content = fs.readFileSync(target, 'utf8');
-        artifact = JSON.parse(content);
-        console.log(`${C.green}  ✓ JSON Syntax Valid${C.reset}`);
-        results.push({ check: 'json_syntax', passed: true });
-        logWitness(home, 'check_passed', { check: 'json_syntax' });
-    } catch (e) {
-        console.log(`${C.red}  ✖ JSON Error: ${e.message}${C.reset}`);
-        results.push({ check: 'json_syntax', passed: false, error: e.message });
-        logWitness(home, 'check_failed', { check: 'json_syntax', error: e.message });
-        process.exit(1);
-    }
-
-    // 2. JOSFOXAI Keys Check
-    const missingJosfoxai = JOSFOXAI_KEYS.filter(k => !artifact[k]);
-    if (missingJosfoxai.length > 0) {
-        console.log(`${C.red}  ✖ Missing JOSFOXAI Keys: ${missingJosfoxai.join(', ')}${C.reset}`);
-        results.push({ check: 'josfoxai_keys', passed: false, missing: missingJosfoxai });
-        logWitness(home, 'check_failed', { check: 'josfoxai_keys', missing: missingJosfoxai });
-        allPassed = false;
-    } else {
-        console.log(`${C.green}  ✓ JOSFOXAI Keys Present (${JOSFOXAI_KEYS.length}/${JOSFOXAI_KEYS.length})${C.reset}`);
-        results.push({ check: 'josfoxai_keys', passed: true });
-        logWitness(home, 'check_passed', { check: 'josfoxai_keys' });
-    }
-
-    // 3. MAGIC Keys Check
-    const missingMagic = MAGIC_KEYS.filter(k => !artifact[k]);
-    if (missingMagic.length > 0) {
-        console.log(`${C.red}  ✖ Missing MAGIC Keys: ${missingMagic.join(', ')}${C.reset}`);
-        results.push({ check: 'magic_keys', passed: false, missing: missingMagic });
-        logWitness(home, 'check_failed', { check: 'magic_keys', missing: missingMagic });
-        allPassed = false;
-    } else {
-        console.log(`${C.green}  ✓ MAGIC Keys Present (${MAGIC_KEYS.length}/${MAGIC_KEYS.length})${C.reset}`);
-        results.push({ check: 'magic_keys', passed: true });
-        logWitness(home, 'check_passed', { check: 'magic_keys' });
-    }
-
-    // 4. Orchestration Structure Check
-    if (artifact.orchestration) {
-        const hasDefinitions = artifact.orchestration.definitions && Object.keys(artifact.orchestration.definitions).length > 0;
-        const hasFlows = artifact.orchestration.flows && Object.keys(artifact.orchestration.flows).length > 0;
-
-        if (hasDefinitions && hasFlows) {
-            const defCount = Object.keys(artifact.orchestration.definitions).length;
-            const flowCount = Object.keys(artifact.orchestration.flows).length;
-            console.log(`${C.green}  ✓ Orchestration Structure (${defCount} definitions, ${flowCount} flows)${C.reset}`);
-            results.push({ check: 'orchestration_structure', passed: true, definitions: defCount, flows: flowCount });
-        } else {
-            console.log(`${C.yellow}  ⚠ Orchestration may be incomplete${C.reset}`);
-            results.push({ check: 'orchestration_structure', passed: true, warning: 'may be incomplete' });
-        }
-    }
-
-    // 5. Integrity Check
-    if (!insecure) {
-        if (artifact.security?.integrity_ref) {
-            const manifestPath = path.resolve(path.dirname(target), artifact.security.integrity_ref);
-            if (fs.existsSync(manifestPath)) {
-                try {
-                    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-                    const hash = crypto.createHash('sha256').update(content).digest('hex');
-                    if (hash === manifest.artifact_sha256) {
-                        console.log(`${C.green}  ✓ Integrity Verified (SHA-256 match)${C.reset}`);
-                        if (verbose) {
-                            console.log(`${C.gray}    Hash: ${hash}${C.reset}`);
-                        }
-                        results.push({ check: 'integrity', passed: true, hash: hash });
-                        logWitness(home, 'integrity_verified', { hash: hash, manifest: artifact.security.integrity_ref });
-                    } else {
-                        console.log(`${C.red}  ✖ Integrity Mismatch!${C.reset}`);
-                        if (verbose) {
-                            console.log(`${C.gray}    Expected: ${manifest.artifact_sha256}${C.reset}`);
-                            console.log(`${C.gray}    Actual:   ${hash}${C.reset}`);
-                        }
-                        results.push({ check: 'integrity', passed: false, expected: manifest.artifact_sha256, actual: hash });
-                        logWitness(home, 'integrity_failed', { expected: manifest.artifact_sha256, actual: hash });
-                        allPassed = false;
-                    }
-                } catch (e) {
-                    console.log(`${C.red}  ✖ Invalid Manifest: ${e.message}${C.reset}`);
-                    results.push({ check: 'integrity', passed: false, error: e.message });
-                    allPassed = false;
-                }
-            } else {
-                console.log(`${C.red}  ✖ Manifest Not Found: ${artifact.security.integrity_ref}${C.reset}`);
-                results.push({ check: 'integrity', passed: false, error: 'manifest not found' });
-                logWitness(home, 'integrity_failed', { error: 'manifest not found' });
-                allPassed = false;
-            }
-        } else {
-            console.log(`${C.yellow}  ⚠ No Integrity Reference (security.integrity_ref)${C.reset}`);
-            results.push({ check: 'integrity', passed: true, warning: 'no integrity_ref' });
-        }
-    } else {
-        console.log(`${C.yellow}  ⚠ Integrity Check Skipped (--insecure)${C.reset}`);
-        results.push({ check: 'integrity', skipped: true });
-    }
-
-    // Summary
-    console.log('');
-    if (allPassed) {
-        console.log(`${C.green}${C.bold}✓ VALIDATION PASSED${C.reset}`);
-        logWitness(home, 'success', { results: results });
-    } else {
-        console.log(`${C.red}${C.bold}✖ VALIDATION FAILED${C.reset}`);
-        logWitness(home, 'failed', { results: results });
-        process.exit(1);
-    }
-    console.log('');
-};
+/**
+ * JOS VALIDATE Command - Validate .jos artifacts
+ * Checks schema, required keys, and integrity
+ * Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    purple: '\x1b[38;5;135m', cyan: '\x1b[38;5;51m',
+    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m',
+    yellow: '\x1b[38;5;220m', gray: '\x1b[38;5;245m'
+};
+
+// Witness Logging
+function logWitness(home, eventType, data) {
+    const runId = global.JOS_VALIDATE_ID || new Date().toISOString().replace(/[:.]/g, '-');
+    global.JOS_VALIDATE_ID = runId;
+
+    const runDir = path.join(home, 'runs', runId);
+    if (!fs.existsSync(runDir)) fs.mkdirSync(runDir, { recursive: true });
+
+    const event = {
+        timestamp: new Date().toISOString(),
+        type: `validate:${eventType}`,
+        ...data
+    };
+
+    fs.appendFileSync(path.join(runDir, 'events.jsonl'), JSON.stringify(event) + '\n');
+}
+
+// Required keys for JOSFOXAI + MAGIC compliance (ALL REQUIRED - NO EXCEPTIONS)
+const JOSFOXAI_KEYS = ['jos', 'orchestration_contract', 'security', 'files', 'orchestration', 'x_run_params', 'adaptive_ai', 'id_jos'];
+const MAGIC_KEYS = ['meta', 'artifacts', 'guardrails', 'intention', 'capabilities'];
+const ALL_REQUIRED_KEYS = [...JOSFOXAI_KEYS, ...MAGIC_KEYS];
+
+exports.execute = async (args, home) => {
+    const target = args[0];
+    const insecure = args.includes('--insecure');
+    const verbose = args.includes('--verbose') || args.includes('-v');
+
+    if (!target || args.includes('--help')) {
+        console.log(`
+${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
+${C.bold}JOS VALIDATE${C.reset} // Validate .jos artifacts (STRICT)
+${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
+
+${C.bold}Usage:${C.reset}
+  jos validate <file.jos> [options]
+
+${C.bold}Options:${C.reset}
+  --insecure    Skip integrity verification
+  --verbose     Show detailed validation information
+
+${C.bold}ALL REQUIRED Keys:${C.reset}
+  JOSFOXAI: ${JOSFOXAI_KEYS.join(', ')}
+  MAGIC: ${MAGIC_KEYS.join(', ')}
+
+${C.bold}Validates:${C.reset}
+  1. JSON syntax
+  2. ALL JOSFOXAI keys (8 required)
+  3. ALL MAGIC keys (5 required)
+  4. Integrity manifest (unless --insecure)
+`);
+        return;
+    }
+
+    console.log(`\n${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+    console.log(`${C.bold}JOS VALIDATE${C.reset} // ${C.gray}Format v0.0.7 — STRICT MODE${C.reset}`);
+    console.log(`${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}`);
+    console.log(`\n${C.cyan}📋 Artifact:${C.reset} ${target}`);
+
+    logWitness(home, 'start', { artifact: target });
+
+    let allPassed = true;
+    const results = [];
+
+    // 1. JSON Syntax Check
+    let content, artifact;
+    try {
+        content = fs.readFileSync(target, 'utf8');
+        artifact = JSON.parse(content);
+        console.log(`${C.green}  ✓ JSON Syntax Valid${C.reset}`);
+        results.push({ check: 'json_syntax', passed: true });
+        logWitness(home, 'check_passed', { check: 'json_syntax' });
+    } catch (e) {
+        console.log(`${C.red}  ✖ JSON Error: ${e.message}${C.reset}`);
+        results.push({ check: 'json_syntax', passed: false, error: e.message });
+        logWitness(home, 'check_failed', { check: 'json_syntax', error: e.message });
+        process.exit(1);
+    }
+
+    // 2. JOSFOXAI Keys Check (ALL 8 REQUIRED)
+    const missingJosfoxai = JOSFOXAI_KEYS.filter(k => !artifact[k]);
+    if (missingJosfoxai.length > 0) {
+        console.log(`${C.red}  ✖ Missing JOSFOXAI Keys: ${missingJosfoxai.join(', ')}${C.reset}`);
+        results.push({ check: 'josfoxai_keys', passed: false, missing: missingJosfoxai });
+        logWitness(home, 'check_failed', { check: 'josfoxai_keys', missing: missingJosfoxai });
+        allPassed = false;
+    } else {
+        console.log(`${C.green}  ✓ JOSFOXAI Keys Present (${JOSFOXAI_KEYS.length}/${JOSFOXAI_KEYS.length})${C.reset}`);
+        results.push({ check: 'josfoxai_keys', passed: true });
+        logWitness(home, 'check_passed', { check: 'josfoxai_keys' });
+    }
+
+    // 3. MAGIC Keys Check (ALL 5 REQUIRED)
+    const missingMagic = MAGIC_KEYS.filter(k => !artifact[k]);
+    if (missingMagic.length > 0) {
+        console.log(`${C.red}  ✖ Missing MAGIC Keys: ${missingMagic.join(', ')}${C.reset}`);
+        results.push({ check: 'magic_keys', passed: false, missing: missingMagic });
+        logWitness(home, 'check_failed', { check: 'magic_keys', missing: missingMagic });
+        allPassed = false;
+    } else {
+        console.log(`${C.green}  ✓ MAGIC Keys Present (${MAGIC_KEYS.length}/${MAGIC_KEYS.length})${C.reset}`);
+        results.push({ check: 'magic_keys', passed: true });
+        logWitness(home, 'check_passed', { check: 'magic_keys' });
+    }
+
+    // 4. Orchestration Structure Check
+    if (artifact.orchestration) {
+        const hasDefinitions = artifact.orchestration.definitions && Object.keys(artifact.orchestration.definitions).length > 0;
+        const hasFlows = artifact.orchestration.flows && Object.keys(artifact.orchestration.flows).length > 0;
+
+        if (hasDefinitions && hasFlows) {
+            const defCount = Object.keys(artifact.orchestration.definitions).length;
+            const flowCount = Object.keys(artifact.orchestration.flows).length;
+            console.log(`${C.green}  ✓ Orchestration Structure (${defCount} definitions, ${flowCount} flows)${C.reset}`);
+            results.push({ check: 'orchestration_structure', passed: true, definitions: defCount, flows: flowCount });
+        } else {
+            console.log(`${C.yellow}  ⚠ Orchestration may be incomplete${C.reset}`);
+            results.push({ check: 'orchestration_structure', passed: true, warning: 'may be incomplete' });
+        }
+    }
+
+    // 5. Integrity Check
+    if (!insecure) {
+        if (artifact.security?.integrity_ref) {
+            const manifestPath = path.resolve(path.dirname(target), artifact.security.integrity_ref);
+            if (fs.existsSync(manifestPath)) {
+                try {
+                    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+                    const hash = crypto.createHash('sha256').update(content).digest('hex');
+                    if (hash === manifest.artifact_sha256) {
+                        console.log(`${C.green}  ✓ Integrity Verified (SHA-256 match)${C.reset}`);
+                        if (verbose) {
+                            console.log(`${C.gray}    Hash: ${hash}${C.reset}`);
+                        }
+                        results.push({ check: 'integrity', passed: true, hash: hash });
+                        logWitness(home, 'integrity_verified', { hash: hash, manifest: artifact.security.integrity_ref });
+                    } else {
+                        console.log(`${C.red}  ✖ Integrity Mismatch!${C.reset}`);
+                        if (verbose) {
+                            console.log(`${C.gray}    Expected: ${manifest.artifact_sha256}${C.reset}`);
+                            console.log(`${C.gray}    Actual:   ${hash}${C.reset}`);
+                        }
+                        results.push({ check: 'integrity', passed: false, expected: manifest.artifact_sha256, actual: hash });
+                        logWitness(home, 'integrity_failed', { expected: manifest.artifact_sha256, actual: hash });
+                        allPassed = false;
+                    }
+                } catch (e) {
+                    console.log(`${C.red}  ✖ Invalid Manifest: ${e.message}${C.reset}`);
+                    results.push({ check: 'integrity', passed: false, error: e.message });
+                    allPassed = false;
+                }
+            } else {
+                console.log(`${C.red}  ✖ Manifest Not Found: ${artifact.security.integrity_ref}${C.reset}`);
+                results.push({ check: 'integrity', passed: false, error: 'manifest not found' });
+                logWitness(home, 'integrity_failed', { error: 'manifest not found' });
+                allPassed = false;
+            }
+        } else {
+            console.log(`${C.yellow}  ⚠ No Integrity Reference (security.integrity_ref)${C.reset}`);
+            results.push({ check: 'integrity', passed: true, warning: 'no integrity_ref' });
+        }
+    } else {
+        console.log(`${C.yellow}  ⚠ Integrity Check Skipped (--insecure)${C.reset}`);
+        results.push({ check: 'integrity', skipped: true });
+    }
+
+    // Summary
+    console.log('');
+    if (allPassed) {
+        console.log(`${C.green}${C.bold}✓ VALIDATION PASSED${C.reset}`);
+        logWitness(home, 'success', { results: results });
+    } else {
+        console.log(`${C.red}${C.bold}✖ VALIDATION FAILED${C.reset}`);
+        logWitness(home, 'failed', { results: results });
+        process.exit(1);
+    }
+    console.log('');
+};

package/src/commands/verify.js

@@ -0,0 +1,98 @@
+/**
+ * JOS VERIFY Command - Self-Verification Suite
+ * Implements "Dogfooding" strategy
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync, execSync } = require('child_process');
+
+const C = {
+    reset: '\x1b[0m', bold: '\x1b[1m',
+    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m',
+    cyan: '\x1b[38;5;51m', gray: '\x1b[38;5;245m',
+    yellow: '\x1b[38;5;220m'
+};
+
+exports.execute = async (args, home) => {
+    console.log(`\n${C.cyan}${C.bold}🦊 JOS Self-Verification${C.reset}\n`);
+
+    const binDir = path.join(__dirname, '..', '..', 'bin');
+    const binJos = path.join(binDir, 'jos');
+
+    // 1. PATH Injection (Crucial for Windows)
+    // We add the bin directory to the front of PATH so 'jos' resolves to our binary
+    const env = { ...process.env, CI: 'true' };
+    env.PATH = process.platform === 'win32'
+        ? `${binDir};${process.env.PATH}`
+        : `${binDir}:${process.env.PATH}`;
+
+    let failed = false;
+
+    // 2. Dogfooding: Run verification.jos
+    console.log(`${C.bold}1. Kernel Smoke Tests (verification.jos)${C.reset}`);
+    const verifyArtifact = path.join(__dirname, '..', '..', 'artifacts', 'verification.jos');
+
+    if (!fs.existsSync(verifyArtifact)) {
+        console.error(`${C.red}✖ Internal Error: verification.jos not found at ${verifyArtifact}${C.reset}`);
+        process.exit(1);
+    }
+
+    try {
+        // We defer to the 'run' command logic by spawning a child process
+        // This ensures identical execution environment to a real user run
+        const result = spawnSync(process.execPath, [binJos, 'run', verifyArtifact], {
+            encoding: 'utf8',
+            env,
+            stdio: 'inherit'
+        });
+
+        if (result.status !== 0) {
+            console.error(`\n${C.red}✖ Smoke tests failed (Exit Code: ${result.status})${C.reset}`);
+            failed = true;
+        } else {
+            console.log(`${C.green}✓ Smoke tests passed${C.reset}`);
+        }
+
+    } catch (e) {
+        console.error(`${C.red}✖ Execution failed: ${e.message}${C.reset}`);
+        failed = true;
+    }
+
+    // 3. Functional Test (Init + Validate)
+    console.log(`\n${C.bold}2. Functional Lifecycle (Init + Validate)${C.reset}`);
+    const TEST_ARTIFACT = 'native-test';
+    const TEST_FILE = `${TEST_ARTIFACT}.jos`;
+
+    // Cleanup
+    if (fs.existsSync(TEST_FILE)) fs.unlinkSync(TEST_FILE);
+
+    try {
+        console.log(`${C.gray}→ Initializing ${TEST_ARTIFACT}...${C.reset}`);
+        execSync(`"${process.execPath}" "${binJos}" init ${TEST_ARTIFACT} --pipeline`, { env, stdio: 'pipe' });
+
+        if (!fs.existsSync(TEST_FILE)) {
+            throw new Error('Artifact file not created');
+        }
+
+        console.log(`${C.gray}→ Validating artifact...${C.reset}`);
+        execSync(`"${process.execPath}" "${binJos}" validate ${TEST_FILE}`, { env, stdio: 'pipe' });
+
+        console.log(`${C.green}✓ Lifecycle tests passed${C.reset}`);
+
+    } catch (e) {
+        console.error(`${C.red}✖ Functional test failed: ${e.message}${C.reset}`);
+        failed = true;
+    } finally {
+        if (fs.existsSync(TEST_FILE)) fs.unlinkSync(TEST_FILE);
+    }
+
+    console.log(`\n${C.gray}----------------------------------------${C.reset}`);
+    if (failed) {
+        console.log(`${C.red}${C.bold}❌ VERIFICATION FAILED${C.reset}`);
+        process.exit(1);
+    } else {
+        console.log(`${C.green}${C.bold}✅ SYSTEM HEALTHY${C.reset}`);
+        process.exit(0);
+    }
+};