@asvanevik/mcli 0.0.5

package/dist/lib.js

@@ -0,0 +1,226 @@
+/**
+ * Compute overall agentScore from detailed agentScores.
+ * Weighted average: json(3) + nonInteractive(3) + tokenEfficiency(2) + safety(1) + pipeline(1)
+ * Returns 1-10 scale.
+ */
+export function computeAgentScore(scores) {
+    const weighted = scores.jsonOutput * 3 +
+        scores.nonInteractive * 3 +
+        scores.tokenEfficiency * 2 +
+        scores.safetyFeatures * 1 +
+        scores.pipelineFriendly * 1;
+    // Max possible = 5*10 = 50, scale to 1-10
+    return Math.round((weighted / 50) * 10);
+}
+/**
+ * Validate agentScores object.
+ */
+export function validateAgentScores(scores) {
+    const errors = [];
+    if (!scores || typeof scores !== 'object') {
+        return { valid: false, errors: ['agentScores must be an object'] };
+    }
+    const s = scores;
+    const dimensions = ['jsonOutput', 'nonInteractive', 'tokenEfficiency', 'safetyFeatures', 'pipelineFriendly'];
+    for (const dim of dimensions) {
+        const val = s[dim];
+        if (typeof val !== 'number' || val < 1 || val > 5 || !Number.isInteger(val)) {
+            errors.push(`agentScores.${dim} must be an integer 1-5`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Search tools by query string.
+ * Matches against slug, name, description, and categories.
+ */
+export function searchTools(registry, query) {
+    const q = query.toLowerCase().trim();
+    if (!q)
+        return [];
+    return registry.tools.filter(tool => tool.slug.toLowerCase().includes(q) ||
+        tool.name.toLowerCase().includes(q) ||
+        tool.description.toLowerCase().includes(q) ||
+        tool.categories.some(c => c.toLowerCase().includes(q)));
+}
+/**
+ * Find a tool by exact slug match.
+ */
+export function findTool(registry, slug) {
+    return registry.tools.find(t => t.slug === slug);
+}
+/**
+ * Get all unique categories from the registry.
+ */
+export function getCategories(registry) {
+    const cats = new Set();
+    registry.tools.forEach(t => t.categories.forEach(c => cats.add(c)));
+    return [...cats].sort();
+}
+/**
+ * Sort tools by agent score (descending).
+ */
+export function sortByAgentScore(tools) {
+    return [...tools].sort((a, b) => b.agentScore - a.agentScore);
+}
+/**
+ * Filter tools by minimum agent score.
+ */
+export function filterByMinScore(tools, minScore) {
+    return tools.filter(t => t.agentScore >= minScore);
+}
+/**
+ * Filter tools by category.
+ */
+export function filterByCategory(tools, category) {
+    const cat = category.toLowerCase();
+    return tools.filter(t => t.categories.some(c => c.toLowerCase() === cat));
+}
+/**
+ * Filter tools by verification tier.
+ */
+export function filterByTier(tools, tier) {
+    return tools.filter(t => t.tier === tier);
+}
+/**
+ * Get tier badge character.
+ */
+export function tierBadge(tier) {
+    switch (tier) {
+        case 'verified': return '✓';
+        case 'community': return '○';
+        default: return '?';
+    }
+}
+/**
+ * Validate a tool object has required fields.
+ */
+export function validateTool(tool) {
+    const errors = [];
+    if (!tool || typeof tool !== 'object') {
+        return { valid: false, errors: ['Tool must be an object'] };
+    }
+    const t = tool;
+    // Required string fields
+    const requiredStrings = ['slug', 'name', 'description'];
+    for (const field of requiredStrings) {
+        if (typeof t[field] !== 'string' || !t[field]) {
+            errors.push(`Missing or invalid field: ${field}`);
+        }
+    }
+    // Slug format: lowercase, alphanumeric, hyphens
+    if (typeof t.slug === 'string' && !/^[a-z0-9-]+$/.test(t.slug)) {
+        errors.push('Slug must be lowercase alphanumeric with hyphens only');
+    }
+    // Agent score: 1-10
+    if (typeof t.agentScore !== 'number' || t.agentScore < 1 || t.agentScore > 10) {
+        errors.push('agentScore must be a number between 1 and 10');
+    }
+    // Tier validation
+    const validTiers = ['verified', 'community', 'unverified'];
+    if (!validTiers.includes(t.tier)) {
+        errors.push(`tier must be one of: ${validTiers.join(', ')}`);
+    }
+    // Categories: non-empty array
+    if (!Array.isArray(t.categories) || t.categories.length === 0) {
+        errors.push('categories must be a non-empty array');
+    }
+    // Vendor object
+    if (!t.vendor || typeof t.vendor !== 'object') {
+        errors.push('vendor must be an object');
+    }
+    else {
+        const v = t.vendor;
+        if (typeof v.name !== 'string' || !v.name)
+            errors.push('vendor.name is required');
+        if (typeof v.domain !== 'string' || !v.domain)
+            errors.push('vendor.domain is required');
+        if (typeof v.verified !== 'boolean')
+            errors.push('vendor.verified must be boolean');
+    }
+    // Install object
+    if (!t.install || typeof t.install !== 'object') {
+        errors.push('install must be an object');
+    }
+    // Capabilities object
+    if (!t.capabilities || typeof t.capabilities !== 'object') {
+        errors.push('capabilities must be an object');
+    }
+    else {
+        const c = t.capabilities;
+        if (typeof c.jsonOutput !== 'boolean')
+            errors.push('capabilities.jsonOutput must be boolean');
+        if (typeof c.idempotent !== 'boolean')
+            errors.push('capabilities.idempotent must be boolean');
+        if (typeof c.interactive !== 'boolean')
+            errors.push('capabilities.interactive must be boolean');
+        if (typeof c.streaming !== 'boolean')
+            errors.push('capabilities.streaming must be boolean');
+        if (!Array.isArray(c.auth))
+            errors.push('capabilities.auth must be an array');
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Validate entire registry.
+ */
+export function validateRegistry(registry) {
+    const errors = [];
+    if (!registry || typeof registry !== 'object') {
+        return { valid: false, errors: ['Registry must be an object'] };
+    }
+    const r = registry;
+    if (typeof r.version !== 'string') {
+        errors.push('Registry must have a version string');
+    }
+    if (!Array.isArray(r.tools)) {
+        errors.push('Registry must have a tools array');
+        return { valid: false, errors };
+    }
+    // Check for duplicate slugs
+    const slugs = new Set();
+    for (const tool of r.tools) {
+        const t = tool;
+        if (typeof t.slug === 'string') {
+            if (slugs.has(t.slug)) {
+                errors.push(`Duplicate slug: ${t.slug}`);
+            }
+            slugs.add(t.slug);
+        }
+        const toolValidation = validateTool(tool);
+        if (!toolValidation.valid) {
+            errors.push(`Tool "${t.slug || 'unknown'}": ${toolValidation.errors.join(', ')}`);
+        }
+    }
+    return { valid: errors.length === 0, errors };
+}
+/**
+ * Generate install command string for a tool and platform.
+ */
+export function getInstallCommand(tool, platform) {
+    const cmd = tool.install[platform];
+    if (!cmd)
+        return null;
+    switch (platform) {
+        case 'brew': return `brew install ${cmd}`;
+        case 'apt': return `sudo apt install ${cmd}`;
+        case 'npm': return `npm install -g ${cmd}`;
+        case 'cargo': return `cargo install ${cmd}`;
+        case 'go': return `go install ${cmd}`;
+        case 'binary': return cmd;
+        case 'script': return cmd;
+        default: return null;
+    }
+}
+export function compareTools(tools) {
+    if (tools.length === 0)
+        return [];
+    return [
+        { field: 'Agent Score', values: tools.map(t => t.agentScore) },
+        { field: 'JSON Output', values: tools.map(t => t.capabilities.jsonOutput) },
+        { field: 'Idempotent', values: tools.map(t => t.capabilities.idempotent) },
+        { field: 'Interactive', values: tools.map(t => t.capabilities.interactive) },
+        { field: 'Streaming', values: tools.map(t => t.capabilities.streaming) },
+        { field: 'Tier', values: tools.map(t => t.tier) },
+    ];
+}

package/dist/registry.d.ts

@@ -0,0 +1,10 @@
+import type { Registry } from './types.js';
+export declare class RegistryError extends Error {
+    cause?: Error | undefined;
+    constructor(message: string, cause?: Error | undefined);
+}
+/**
+ * Load and validate registry from a JSON file.
+ * @throws {RegistryError} If file is missing, malformed, or invalid
+ */
+export declare function loadRegistry(path: string): Registry;

package/dist/registry.js

@@ -0,0 +1,46 @@
+/**
+ * Registry loading with proper error handling.
+ * Extracted for testability.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { validateRegistry } from './lib.js';
+export class RegistryError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'RegistryError';
+    }
+}
+/**
+ * Load and validate registry from a JSON file.
+ * @throws {RegistryError} If file is missing, malformed, or invalid
+ */
+export function loadRegistry(path) {
+    // Check file exists
+    if (!existsSync(path)) {
+        throw new RegistryError(`Registry file not found: ${path}`);
+    }
+    // Read file
+    let content;
+    try {
+        content = readFileSync(path, 'utf-8');
+    }
+    catch (err) {
+        throw new RegistryError(`Failed to read registry file: ${path}`, err instanceof Error ? err : undefined);
+    }
+    // Parse JSON
+    let data;
+    try {
+        data = JSON.parse(content);
+    }
+    catch (err) {
+        throw new RegistryError(`Registry file contains invalid JSON: ${path}`, err instanceof Error ? err : undefined);
+    }
+    // Validate schema
+    const validation = validateRegistry(data);
+    if (!validation.valid) {
+        throw new RegistryError(`Registry validation failed: ${validation.errors.join('; ')}`);
+    }
+    return data;
+}

package/dist/types.d.ts

@@ -0,0 +1,56 @@
+export interface Vendor {
+    name: string;
+    domain: string;
+    verified: boolean;
+}
+export interface InstallMethods {
+    brew?: string;
+    apt?: string;
+    npm?: string;
+    cargo?: string;
+    go?: string;
+    binary?: string;
+    script?: string;
+}
+export interface Capabilities {
+    jsonOutput: boolean;
+    auth: string[];
+    idempotent: boolean;
+    interactive: boolean;
+    streaming: boolean;
+}
+/**
+ * Multi-dimensional agent-friendliness scores.
+ * Each dimension is 1-5 (5 = best).
+ */
+export interface AgentScores {
+    /** Structured output: --json, --output=json, parseable formats */
+    jsonOutput: number;
+    /** Non-interactive: --yes, env auth, no prompts, no TTY required */
+    nonInteractive: number;
+    /** Token efficiency: --quiet, --compact, --id-only, minimal output */
+    tokenEfficiency: number;
+    /** Safety features: --dry-run, structured exit codes (0/1/2), confirmation flags */
+    safetyFeatures: number;
+    /** Pipeline friendly: clean stderr/stdout separation, chainable output */
+    pipelineFriendly: number;
+}
+export interface CliTool {
+    slug: string;
+    name: string;
+    vendor: Vendor;
+    repo?: string;
+    docs?: string;
+    install: InstallMethods;
+    capabilities: Capabilities;
+    agentScore: number;
+    agentScores?: AgentScores;
+    categories: string[];
+    description: string;
+    tier: 'verified' | 'community' | 'unverified';
+}
+export interface Registry {
+    version: string;
+    updated: string;
+    tools: CliTool[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@asvanevik/mcli",
+  "version": "0.0.5",
+  "description": "A CLI for discovering and comparing CLI tools",
+  "type": "module",
+  "bin": {
+    "mcli": "./bin/mcli.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "registry"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "keywords": [
+    "cli",
+    "tools",
+    "discovery",
+    "registry"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@types/node": "^25.3.2",
+    "@vitest/coverage-v8": "^4.0.18",
+    "openai": "^6.25.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}