@josfox/jos 4.0.8 → 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/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);
-    }
-};

package/src/commands/repo.js

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