@josfox/jos 4.1.0 → 5.0.0

package/src/ui.js

@@ -0,0 +1,98 @@
+'use strict';
+// The one style module of the host (STYLE.md). Every line written for a person goes through a printer of this file:
+// the header with rules, the marks ✓ ✖ ⚠, the colors and the indentation live here and nowhere else. Colors are off
+// when NO_COLOR is set or the stream is not a terminal, so piped output carries no escape codes. Machine output
+// (`--json`) and data that is not a message (a child's output, a revealed value) also leave through this file, by
+// json() and data(), which never add color or decoration.
+
+const FULL = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    purple: '\x1b[38;5;135m', magenta: '\x1b[38;5;198m', cyan: '\x1b[38;5;51m',
+    blue: '\x1b[38;5;39m', white: '\x1b[38;5;255m', gray: '\x1b[38;5;245m',
+    pink: '\x1b[38;5;213m', teal: '\x1b[38;5;44m',
+    green: '\x1b[38;5;78m', red: '\x1b[38;5;196m', yellow: '\x1b[38;5;220m',
+};
+
+const BASIC = {
+    reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+    purple: '\x1b[35m', magenta: '\x1b[35m', cyan: '\x1b[36m',
+    blue: '\x1b[34m', white: '\x1b[37m', gray: '\x1b[90m',
+    pink: '\x1b[35m', teal: '\x1b[36m',
+    green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m',
+};
+
+function supports256Color() {
+    const term = process.env.TERM || '';
+    const colorterm = process.env.COLORTERM || '';
+    return term.includes('256color') || colorterm === 'truecolor' ||
+        colorterm === '24bit' || process.platform === 'darwin';
+}
+
+function supportsUnicode() {
+    const term = process.env.TERM || '';
+    const lang = process.env.LANG || '';
+    if (lang && !lang.includes('UTF-8') && !lang.includes('utf8')) return false;
+    return lang.includes('UTF-8') || lang.includes('utf8') ||
+        term.includes('xterm') || term.includes('256color') ||
+        (process.platform === 'darwin' && !lang);
+}
+
+function palette(stream) {
+    const on = !process.env.NO_COLOR && stream && stream.isTTY;
+    const src = supports256Color() ? FULL : BASIC;
+    const out = {};
+    for (const k of Object.keys(FULL)) out[k] = on ? src[k] : '';
+    return out;
+}
+
+const RULE = '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━';
+
+// A printer bound to one stream (process.stdout, process.stderr or a stream a test passes in). The stream's write
+// is looked up on every call, so a test that replaces process.stdout.write sees every line.
+//   header(title, sub)   blank line, rule, "TITLE // sub", rule, blank line
+//   ok / fail / warn     "✓ text", "✖ text", "⚠ text" in green / red / yellow, then an optional gray detail
+//   step                 "▶ text" in cyan: something that starts now (a command the MCP client runs)
+//   hint(text)           an indented, dimmed follow-up line (usage, next step, why)
+//   field(label, value)  an indented "label: value" line
+//   item(text)           an indented "• text" line
+//   cmd(text)            an indented command to copy: "    $ text"
+//   line(s) / text(s)    a line, or a block or prompt written as given (composed with C, this printer's palette)
+function printer(stream) {
+    const C = palette(stream);
+    const text = (s) => { stream.write(s); };
+    const line = (s) => text((s === undefined ? '' : s) + '\n');
+    const mark = (color, sign) => (s, detail) => line(`${C[color]}${sign} ${s}${C.reset}` + (detail ? ` ${C.gray}${detail}${C.reset}` : ''));
+    return {
+        C,
+        text,
+        line,
+        header(title, sub) {
+            line();
+            line(`${C.purple}${RULE}${C.reset}`);
+            line(`${C.bold}${title}${C.reset}` + (sub ? ` // ${C.gray}${sub}${C.reset}` : ''));
+            line(`${C.purple}${RULE}${C.reset}`);
+            line();
+        },
+        ok: mark('green', '✓'),
+        fail: mark('red', '✖'),
+        warn: mark('yellow', '⚠'),
+        step: mark('cyan', '▶'),
+        hint: (s) => line(`  ${C.dim}${s}${C.reset}`),
+        field: (label, value) => line(`  ${C.cyan}${label}:${C.reset} ${value}`),
+        item: (s) => line(`  ${C.white}•${C.reset} ${s}`),
+        cmd: (s) => line(`    ${C.gray}$${C.reset} ${C.cyan}${s}${C.reset}`),
+    };
+}
+
+// Machine output (--json): plain JSON, two-space indent, one final newline; never colored, whatever the terminal.
+function json(stream, value) { stream.write(JSON.stringify(value, null, 2) + '\n'); }
+
+// Data that is not a message (a child's stdout or stderr, a value revealed on a terminal): written byte for byte.
+function data(stream, chunk) { stream.write(chunk); }
+
+// One argument as a POSIX shell word, for commands printed to be copied: left as is when it is plain, else quoted.
+function shellArg(s) {
+    return /^[A-Za-z0-9_@%+=:,./-]+$/.test(s) ? s : "'" + s.replace(/'/g, "'\\''") + "'";
+}
+
+module.exports = { palette, supportsUnicode, RULE, printer, json, data, shellArg };

package/src/adapters/index.js

@@ -1,16 +0,0 @@
-const NativeAdapter = require('./native');
-const OllamaAdapter = require('./ollama');
-
-/**
- * Adapter Factory
- * Returns the appropriate adapter based on provider type
- */
-exports.getAdapter = (type) => {
-    switch (type) {
-        case 'ollama':
-            return OllamaAdapter;
-        case 'native':
-        default:
-            return NativeAdapter;
-    }
-};

package/src/adapters/native.js

@@ -1,41 +0,0 @@
-/**
- * Native JOS Adapter
- * Connects to the standard JOS Prompts API (e.g. josfox.cloud)
- */
-const { apiRequest } = require('../utils/request');
-
-module.exports = {
-    type: 'native',
-
-    async optimize(artifact, options, providerUrl, model, apiKey) {
-        const res = await apiRequest(`${providerUrl}/optimize`, 'POST', {
-            artifact, options, format_version: '0.0.7'
-        }, apiKey);
-        if (res.status !== 200) throw new Error(res.data?.error?.message || `API ${res.status}`);
-        return res.data;
-    },
-
-    async validate(artifact, providerUrl, model, apiKey) {
-        const res = await apiRequest(`${providerUrl}/validate`, 'POST', {
-            artifact, format_version: '0.0.7'
-        }, apiKey);
-        if (res.status !== 200) throw new Error(res.data?.error?.message || `API ${res.status}`);
-        return res.data;
-    },
-
-    async generate(intention, options, providerUrl, model, apiKey) {
-        const res = await apiRequest(`${providerUrl}/generate`, 'POST', {
-            intention, options, format_version: '0.0.7'
-        }, apiKey);
-        if (res.status !== 200) throw new Error(res.data?.error?.message || `API ${res.status}`);
-        return res.data;
-    },
-
-    async execute(artifact, providerUrl, model, apiKey) {
-        const res = await apiRequest(`${providerUrl}/execute`, 'POST', {
-            artifact, format_version: '0.0.7'
-        }, apiKey);
-        if (res.status !== 200) throw new Error(res.data?.error?.message || `API ${res.status}`);
-        return res.data;
-    }
-};

package/src/adapters/ollama.js

@@ -1,140 +0,0 @@
-/**
- * [EXPERIMENTAL] Ollama Adapter
- * Adapts JOS Intentions to Local LLM Prompts
- */
-const { apiRequest } = require('../utils/request');
-
-const C = {
-    dim: '\x1b[2m',
-    reset: '\x1b[0m'
-};
-
-async function callOllama(baseUrl, model, messages) {
-    // Ensure URL ends with /api/chat
-    const endpoint = baseUrl.endsWith('/api/chat') ? baseUrl : `${baseUrl.replace(/\/$/, '')}/api/chat`;
-
-    console.log(`${C.dim}Connecting to Ollama at ${endpoint}...${C.reset}`);
-
-    return apiRequest(endpoint, 'POST', {
-        model: model || 'llama3', // Default to llama3 if not specified
-        messages: messages,
-        stream: false,
-        format: 'json' // Force JSON mode for structure
-    });
-}
-
-module.exports = {
-    type: 'ollama',
-    experimental: true,
-
-    async optimize(artifact, options, providerUrl, model) {
-        const prompt = `You are an expert prompt engineer specializing in JOS (JSON Orchestration Spec).
-        Your goal is to optimize the PROMPTS inside the following JOS artifact.
-        
-        GOALS: ${options.optimization_goals.join(', ')}
-        
-        INPUT ARTIFACT:
-        ${JSON.stringify(artifact, null, 2)}
-        
-        INSTRUCTIONS:
-        1. Analyze the 'intention' and 'tasks'.
-        2. Rewrite task descriptions to be more precise, using Chain-of-Thought or clear directives.
-        3. Do NOT change the structure or keys. Only text content.
-        4. Return the COMPLETE logical JSON of the optimized artifact.
-        `;
-
-        const res = await callOllama(providerUrl, model, [{ role: 'user', content: prompt }]);
-
-        if (res.status !== 200) throw new Error(`Ollama Error: ${res.status} ${JSON.stringify(res.data)}`);
-
-        const optimizedArtifact = typeof res.data.message.content === 'string'
-            ? JSON.parse(res.data.message.content)
-            : res.data.message.content;
-
-        // Mock quality score for local execution
-        return {
-            optimized_artifact: optimizedArtifact,
-            quality_score: { before: 0.5, after: 0.9 },
-            changes: [{ field: 'tasks', original: '...', optimized: '...', reason: 'Ollama Optimization' }]
-        };
-    },
-
-    async validate(artifact, providerUrl, model) {
-        const prompt = `You are a QA Validator for JOS Artifacts.
-        Analyze the following artifact for logical consistency, missing context, or vague prompts.
-        
-        ARTIFACT:
-        ${JSON.stringify(artifact, null, 2)}
-        
-        Return a JSON object with:
-        - valid (boolean)
-        - quality_score (0.0 to 1.0)
-        - issues (array of objects { field, message, severity })
-        - suggestions (array of objects { field, suggestion })
-        `;
-
-        const res = await callOllama(providerUrl, model, [{ role: 'user', content: prompt }]);
-        if (res.status !== 200) throw new Error(`Ollama Error: ${res.status}`);
-
-        return typeof res.data.message.content === 'string'
-            ? JSON.parse(res.data.message.content)
-            : res.data.message.content;
-    },
-
-    async generate(intention, options, providerUrl, model) {
-        const prompt = `You are a JOS Architect. Generate a valid .jos JSON artifact based on this user intention.
-        
-        INTENTION: "${intention}"
-        
-        REQUIREMENTS:
-        - Type: ${options.type || 'task'}
-        - Format: JOS v0.0.7 (JSON)
-        - Must include 'intention', 'tasks', and 'orchestration'.
-        
-        Return ONLY the JSON.
-        `;
-
-        const res = await callOllama(providerUrl, model, [{ role: 'user', content: prompt }]);
-        if (res.status !== 200) throw new Error(`Ollama Error: ${res.status}`);
-
-        const artifact = typeof res.data.message.content === 'string'
-            ? JSON.parse(res.data.message.content)
-            : res.data.message.content;
-
-        return {
-            confidence: 0.85,
-            artifact: artifact,
-            assumptions: ['Generated by Local Ollama']
-        };
-    },
-
-    async execute(artifact, providerUrl, model) {
-        // MAGIC JOSFOXAI PROMPT WRAPPER
-        const systemPrompt = `[SYSTEM]
-You are an Intention-Native Agent powered by JOSFOXAI.
-MAGIC_KEY: JOSFOX_ALPHA_V1
-
-You are executing the following JOS Artifact.
-Strictly adhere to the 'orchestration' flow and 'requirements'.
-
-ARTIFACT:
-${JSON.stringify(artifact, null, 2)}
-`;
-
-        const userPrompt = `Execute the intention defined in the artifact. Report your status.`;
-
-        const res = await callOllama(providerUrl, model, [
-            { role: 'system', content: systemPrompt },
-            { role: 'user', content: userPrompt }
-        ]);
-
-        if (res.status !== 200) throw new Error(`Ollama Error: ${res.status}`);
-
-        // For non-native adapters, the result is text/chat, which we wrap in a JOS result structure
-        return {
-            status: 'completed',
-            output: typeof res.data.message.content === 'string' ? res.data.message.content : JSON.stringify(res.data.message.content),
-            provider: 'ollama'
-        };
-    }
-};

package/src/commands/add.js

@@ -1,145 +0,0 @@
-/**
- * JOS ADD Command - Add task definitions to .jos artifacts
- * 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',
-    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'
-};
-
-exports.execute = async (args, home) => {
-    const help = args.includes('--help') || args.includes('-h');
-
-    if (help || args.length < 2) {
-        console.log(`
-${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
-${C.bold}JOS ADD${C.reset} // Add task definitions to .jos artifacts
-${C.purple}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
-
-${C.bold}Usage:${C.reset}
-  jos add <task-name> <file.jos> [options]
-
-${C.bold}Options:${C.reset}
-  --type <shell|jos>     Task type (default: shell)
-  --command <cmd>        Shell command to execute
-  --artifact <path>      Path to sub-artifact (for type=jos)
-  --description <desc>   Task description
-  --flow <name>          Also add to this flow's steps
-
-${C.bold}Examples:${C.reset}
-  jos add build my-artifact.jos --command "npm run build"
-  jos add deploy my-artifact.jos --type jos --artifact ./deploy.jos
-  jos add test my-artifact.jos --command "npm test" --flow main
-`);
-        return;
-    }
-
-    const taskName = args[0];
-    const targetFile = args[1];
-
-    // Parse options
-    const getArg = (flag) => {
-        const idx = args.indexOf(flag);
-        return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
-    };
-
-    const taskType = getArg('--type') || 'shell';
-    const command = getArg('--command');
-    const artifact = getArg('--artifact');
-    const description = getArg('--description') || `Task: ${taskName}`;
-    const flowName = getArg('--flow');
-
-    // Validate
-    if (taskType === 'shell' && !command) {
-        console.log(`${C.red}✖ Error: --command is required for shell tasks${C.reset}`);
-        process.exit(1);
-    }
-    if (taskType === 'jos' && !artifact) {
-        console.log(`${C.red}✖ Error: --artifact is required for jos tasks${C.reset}`);
-        process.exit(1);
-    }
-
-    // Load artifact
-    let artifactPath = path.resolve(targetFile);
-    if (!fs.existsSync(artifactPath)) {
-        console.log(`${C.red}✖ Artifact not found: ${targetFile}${C.reset}`);
-        process.exit(1);
-    }
-
-    let content;
-    try {
-        content = JSON.parse(fs.readFileSync(artifactPath, 'utf8'));
-    } catch (e) {
-        console.log(`${C.red}✖ Invalid JSON: ${e.message}${C.reset}`);
-        process.exit(1);
-    }
-
-    // Ensure orchestration structure exists
-    if (!content.orchestration) content.orchestration = {};
-    if (!content.orchestration.definitions) content.orchestration.definitions = {};
-    if (!content.orchestration.flows) content.orchestration.flows = {};
-    if (!content.orchestration.flows.main) content.orchestration.flows.main = { steps: [] };
-
-    // Check for duplicate
-    if (content.orchestration.definitions[taskName]) {
-        console.log(`${C.yellow}⚠ Task '${taskName}' already exists. Overwriting...${C.reset}`);
-    }
-
-    // Add task definition
-    const taskDef = {
-        type: taskType,
-        description: description
-    };
-
-    if (taskType === 'shell') {
-        taskDef.command = command;
-    } else if (taskType === 'jos') {
-        taskDef.artifact = artifact;
-    }
-
-    content.orchestration.definitions[taskName] = taskDef;
-    console.log(`${C.green}✓ Added task definition: ${taskName}${C.reset}`);
-
-    // Add to flow if specified
-    if (flowName) {
-        if (!content.orchestration.flows[flowName]) {
-            content.orchestration.flows[flowName] = { steps: [] };
-        }
-        if (!content.orchestration.flows[flowName].steps.includes(taskName)) {
-            content.orchestration.flows[flowName].steps.push(taskName);
-            console.log(`${C.green}✓ Added to flow: ${flowName}${C.reset}`);
-        }
-    }
-
-    // Write updated artifact
-    fs.writeFileSync(artifactPath, JSON.stringify(content, null, 2));
-    console.log(`${C.green}✓ Updated: ${targetFile}${C.reset}`);
-
-    // Regenerate manifest
-    const manifestPath = artifactPath + '.sig.json';
-    const newContent = fs.readFileSync(artifactPath, 'utf8');
-    const sha256 = crypto.createHash('sha256').update(newContent).digest('hex');
-    const stats = fs.statSync(artifactPath);
-
-    const manifest = {
-        "$schema": "https://josfox.ai/schemas/jos-manifest-0.0.7.json",
-        "manifest_version": "1.0.0",
-        "artifact_ref": path.basename(artifactPath),
-        "artifact_sha256": sha256,
-        "artifact_size_bytes": stats.size,
-        "timestamp": new Date().toISOString(),
-        "generated_by": "jos add command",
-        "canonical_version": "Format version v0.0.7 — Specification maturity v0.1.0 (Alpha)"
-    };
-
-    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-    console.log(`${C.green}✓ Updated manifest: ${path.basename(manifestPath)}${C.reset}`);
-    console.log(`${C.gray}  SHA256: ${sha256}${C.reset}`);
-};

package/src/commands/get.js

@@ -1,245 +0,0 @@
-/**
- * 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);
-    }
-};