@orchagent/cli 0.1.0

package/dist/lib/llm.js

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * LLM Provider Abstraction
+ *
+ * Centralized LLM provider configuration and utilities.
+ * Used by run, call, and skill commands.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MODELS = exports.PROVIDER_ENV_VARS = void 0;
+exports.detectLlmKeyFromEnv = detectLlmKeyFromEnv;
+exports.detectLlmKey = detectLlmKey;
+exports.getDefaultModel = getDefaultModel;
+exports.buildPrompt = buildPrompt;
+exports.callLlm = callLlm;
+exports.validateProvider = validateProvider;
+const errors_1 = require("./errors");
+// Environment variable names for each provider
+exports.PROVIDER_ENV_VARS = {
+    openai: 'OPENAI_API_KEY',
+    anthropic: 'ANTHROPIC_API_KEY',
+    gemini: 'GEMINI_API_KEY',
+};
+// Default models for each provider
+exports.DEFAULT_MODELS = {
+    openai: 'gpt-4o',
+    anthropic: 'claude-sonnet-4-20250514',
+    gemini: 'gemini-1.5-pro',
+};
+/**
+ * Detect LLM API key from environment variables based on supported providers.
+ * Returns the first matching provider/key pair found.
+ */
+function detectLlmKeyFromEnv(supportedProviders) {
+    for (const provider of supportedProviders) {
+        if (provider === 'any') {
+            // 'any' means check all providers in order
+            for (const [p, envVar] of Object.entries(exports.PROVIDER_ENV_VARS)) {
+                const key = process.env[envVar];
+                if (key) {
+                    return { provider: p, key };
+                }
+            }
+        }
+        else {
+            const envVar = exports.PROVIDER_ENV_VARS[provider];
+            if (envVar) {
+                const key = process.env[envVar];
+                if (key) {
+                    return { provider, key };
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Detect LLM API key with server fallback.
+ * Checks local env vars first, then fetches from server if available.
+ * Returns provider, key, and optionally the model from server config.
+ */
+async function detectLlmKey(supportedProviders, config) {
+    // 1. Check local env vars first (fast path)
+    const envKey = detectLlmKeyFromEnv(supportedProviders);
+    if (envKey)
+        return envKey;
+    // 2. If no env var, try server
+    if (config?.apiKey) {
+        try {
+            const { fetchLlmKeys } = await Promise.resolve().then(() => __importStar(require('./api')));
+            const serverKeys = await fetchLlmKeys(config);
+            for (const provider of supportedProviders) {
+                if (provider === 'any') {
+                    // Return first available key
+                    if (serverKeys.length > 0) {
+                        const first = serverKeys[0];
+                        return { provider: first.provider, key: first.api_key, model: first.model };
+                    }
+                }
+                else {
+                    const match = serverKeys.find((k) => k.provider === provider);
+                    if (match) {
+                        return { provider: match.provider, key: match.api_key, model: match.model };
+                    }
+                }
+            }
+        }
+        catch {
+            // Server fetch failed, continue without
+        }
+    }
+    return null;
+}
+/**
+ * Get the default model for a provider.
+ */
+function getDefaultModel(provider) {
+    return exports.DEFAULT_MODELS[provider] || 'gpt-4o';
+}
+/**
+ * Build a full prompt by injecting input data into the template.
+ * Matches server behavior in gateway/src/gateway/llm.py:build_prompt
+ */
+function buildPrompt(template, inputData) {
+    let prompt = template;
+    // Simple variable substitution: {{key}} -> value
+    for (const [key, value] of Object.entries(inputData)) {
+        const placeholder = `{{${key}}}`;
+        if (prompt.includes(placeholder)) {
+            prompt = prompt.split(placeholder).join(String(value));
+        }
+    }
+    // Also append input as JSON for complex inputs
+    if (Object.keys(inputData).length > 0) {
+        prompt += `\n\nInput:\n\`\`\`json\n${JSON.stringify(inputData, null, 2)}\n\`\`\``;
+    }
+    return prompt;
+}
+/**
+ * Call an LLM provider directly (for local execution).
+ */
+async function callLlm(provider, apiKey, model, prompt, outputSchema) {
+    if (provider === 'openai') {
+        return callOpenAI(apiKey, model, prompt, outputSchema);
+    }
+    else if (provider === 'anthropic') {
+        return callAnthropic(apiKey, model, prompt, outputSchema);
+    }
+    else if (provider === 'gemini') {
+        return callGemini(apiKey, model, prompt, outputSchema);
+    }
+    throw new errors_1.CliError(`Unsupported provider: ${provider}`);
+}
+async function callOpenAI(apiKey, model, prompt, outputSchema) {
+    const body = {
+        model,
+        messages: [{ role: 'user', content: prompt }],
+    };
+    if (outputSchema) {
+        body.response_format = { type: 'json_object' };
+    }
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new errors_1.CliError(`OpenAI API error: ${text}`);
+    }
+    const data = (await response.json());
+    const content = data.choices?.[0]?.message?.content || '';
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return { result: content };
+    }
+}
+async function callAnthropic(apiKey, model, prompt, _outputSchema) {
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify({
+            model,
+            max_tokens: 4096,
+            messages: [{ role: 'user', content: prompt }],
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new errors_1.CliError(`Anthropic API error: ${text}`);
+    }
+    const data = (await response.json());
+    const content = data.content?.[0]?.text || '';
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return { result: content };
+    }
+}
+async function callGemini(apiKey, model, prompt, _outputSchema) {
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            contents: [{ parts: [{ text: prompt }] }],
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new errors_1.CliError(`Gemini API error: ${text}`);
+    }
+    const data = (await response.json());
+    const content = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return { result: content };
+    }
+}
+/**
+ * Validate a provider string against known providers.
+ */
+function validateProvider(provider) {
+    const validProviders = ['openai', 'anthropic', 'gemini'];
+    if (!validProviders.includes(provider)) {
+        throw new errors_1.CliError(`Invalid provider: ${provider}. Valid: ${validProviders.join(', ')}`);
+    }
+}

package/dist/lib/output.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printJson = printJson;
+exports.printAgentsTable = printAgentsTable;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function printAgentsTable(agents) {
+    const table = new cli_table3_1.default({
+        head: [
+            chalk_1.default.bold('Agent'),
+            chalk_1.default.bold('Type'),
+            chalk_1.default.bold('Providers'),
+            chalk_1.default.bold('Stars'),
+            chalk_1.default.bold('Description'),
+        ],
+    });
+    agents.forEach((agent) => {
+        const fullName = `${agent.org_slug}/${agent.name}`;
+        const type = agent.type === 'prompt' ? 'prompt' : 'code';
+        const providers = formatProviders(agent.supported_providers);
+        const stars = agent.stars_count ?? 0;
+        const desc = agent.description
+            ? agent.description.length > 30
+                ? agent.description.slice(0, 27) + '...'
+                : agent.description
+            : '-';
+        table.push([fullName, type, providers, stars.toString(), desc]);
+    });
+    process.stdout.write(`${table.toString()}\n`);
+}
+function formatProviders(providers) {
+    if (!providers || providers.length === 0 || providers.includes('any')) {
+        return chalk_1.default.green('any');
+    }
+    return providers.map(p => {
+        if (p === 'openai')
+            return chalk_1.default.cyan('openai');
+        if (p === 'anthropic')
+            return chalk_1.default.magenta('anthropic');
+        if (p === 'gemini')
+            return chalk_1.default.yellow('gemini');
+        return p;
+    }).join(', ');
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@orchagent/cli",
+  "version": "0.1.0",
+  "description": "Command-line interface for the OrchAgent AI agent marketplace",
+  "license": "MIT",
+  "author": "OrchAgent <hello@orchagent.io>",
+  "homepage": "https://orchagent.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/orchagent/orchagent.git",
+    "directory": "cli"
+  },
+  "bugs": {
+    "url": "https://github.com/orchagent/orchagent/issues"
+  },
+  "keywords": [
+    "orchagent",
+    "ai",
+    "agents",
+    "cli",
+    "marketplace",
+    "llm"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "orchagent": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@sentry/node": "^9.3.0",
+    "archiver": "^7.0.0",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.3",
+    "commander": "^11.1.0",
+    "open": "^10.0.0",
+    "posthog-node": "^4.0.0",
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.0",
+    "@types/node": "^20.14.2",
+    "@vitest/coverage-v8": "^2.1.0",
+    "typescript": "^5.9.3",
+    "vitest": "^2.1.0"
+  }
+}