@crystalplatforms/adm 0.2.3

package/src/integrations/ai-backend.js

@@ -0,0 +1,60 @@
+const FLASH_MODELS = ['glm-4.7-flash', 'glm-4-flash', 'glm-z1-flash'];
+const DEFAULT_MAX_TOKENS = 1024;
+const API_BASE = 'https://open.bigmodel.cn/api/paas/v4';
+
+function createClient({ apiKey } = {}) {
+  const key = apiKey || process.env.GLM_API_KEY;
+  if (!key) return null;
+  return { apiKey: key, model: FLASH_MODELS[0] };
+}
+
+async function query(prompt, options = {}) {
+  const client = options.client || createClient({ apiKey: options.apiKey });
+  if (!client) throw new Error('AI not configured. Set GLM_API_KEY or run /setup.');
+
+  const models = options.model ? [options.model] : FLASH_MODELS;
+  let lastError;
+
+  for (const model of models) {
+    const body = {
+      model,
+      max_tokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+      messages: options.messages || [{ role: 'user', content: prompt }],
+    };
+
+    try {
+      const res = await fetch(`${API_BASE}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${client.apiKey}`,
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        if (res.status === 429 && models.indexOf(model) < models.length - 1) {
+          lastError = text;
+          continue;
+        }
+        throw new Error(`API returned ${res.status}: ${text}`);
+      }
+
+      const response = await res.json();
+      const choice = response.choices && response.choices[0];
+      if (!choice || !choice.message) throw new Error('AI returned empty response.');
+      return choice.message.content;
+    } catch (err) {
+      const msg = err.message || '';
+      if (msg.includes('401') || msg.includes('auth')) {
+        throw new Error(`AI authentication failed. Check your API key. (${msg})`);
+      }
+      lastError = msg;
+    }
+  }
+
+  throw new Error(`AI request failed (all models tried): ${lastError}`);
+}
+
+module.exports = { createClient, query };

package/src/integrations/ai-providers/registry.js

@@ -0,0 +1,261 @@
+const PROVIDERS = [
+  { id: 'glm', name: 'GLM', requiresAuth: true },
+  { id: 'openai', name: 'OpenAI', requiresAuth: true },
+  { id: 'anthropic', name: 'Anthropic Claude', requiresAuth: true },
+  { id: 'ollama', name: 'Ollama (local)', requiresAuth: false },
+  { id: 'groq', name: 'Groq', requiresAuth: true },
+  { id: 'deepseek', name: 'DeepSeek', requiresAuth: true },
+  { id: 'mistral', name: 'Mistral AI', requiresAuth: true },
+  { id: 'perplexity', name: 'Perplexity', requiresAuth: true },
+  { id: 'openrouter', name: 'OpenRouter', requiresAuth: true },
+  { id: 'together', name: 'Together AI', requiresAuth: true },
+  { id: 'fireworks', name: 'Fireworks AI', requiresAuth: true },
+  { id: 'xai', name: 'Grok (xAI)', requiresAuth: true },
+  { id: 'gemini', name: 'Google Gemini', requiresAuth: true },
+  { id: 'cohere', name: 'Cohere', requiresAuth: true },
+  { id: 'qwen', name: 'Qwen', requiresAuth: true },
+];
+
+const GLM_API_BASE = 'https://open.bigmodel.cn/api/paas/v4';
+const GLM_MODELS = ['glm-4.7-flash', 'glm-4-flash', 'glm-z1-flash'];
+
+function listProviders() {
+  return PROVIDERS;
+}
+
+function getProvider(id) {
+  return PROVIDERS.find(p => p.id === id) || null;
+}
+
+async function queryGlmFree(prompt, options = {}) {
+  const apiKey = options.apiKey || process.env.GLM_API_KEY;
+  if (!apiKey) throw new Error('GLM requires GLM_API_KEY. Set it with /model glm.');
+
+  const messages = options.messages || [{ role: 'user', content: prompt }];
+  const body = {
+    model: options.model || GLM_MODELS[0],
+    max_tokens: options.maxTokens || 1024,
+    messages,
+  };
+
+  const res = await fetch(`${GLM_API_BASE}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`GLM API returned ${res.status}: ${text}`);
+  }
+
+  const response = await res.json();
+  const choice = response.choices && response.choices[0];
+  if (!choice || !choice.message) throw new Error('GLM returned empty response.');
+  return choice.message.content;
+}
+
+function openaiCompatible(baseUrl, defaultModel, providerName) {
+  return async function queryOpenaiCompat(prompt, options = {}) {
+    const apiKey = options.apiKey;
+    if (!apiKey) throw new Error(`${providerName} requires an API key. Set it with /model ${providerName.toLowerCase()}.`);
+
+    const messages = options.messages || [{ role: 'user', content: prompt }];
+    const body = {
+      model: options.model || defaultModel,
+      max_tokens: options.maxTokens || 1024,
+      messages,
+    };
+
+    const res = await fetch(`${baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`${providerName} API returned ${res.status}: ${text}`);
+    }
+
+    const response = await res.json();
+    const choice = response.choices && response.choices[0];
+    if (!choice || !choice.message) throw new Error(`${providerName} returned empty response.`);
+    return choice.message.content;
+  };
+}
+
+const queryOpenai = openaiCompatible('https://api.openai.com/v1', 'gpt-4o-mini', 'OpenAI');
+const queryGroq = openaiCompatible('https://api.groq.com/openai/v1', 'llama-3.3-70b-versatile', 'Groq');
+const queryDeepseek = openaiCompatible('https://api.deepseek.com/v1', 'deepseek-chat', 'DeepSeek');
+const queryMistral = openaiCompatible('https://api.mistral.ai/v1', 'mistral-large-latest', 'Mistral');
+const queryPerplexity = openaiCompatible('https://api.perplexity.ai', 'sonar', 'Perplexity');
+const queryOpenrouter = openaiCompatible('https://openrouter.ai/api/v1', 'auto', 'OpenRouter');
+const queryTogether = openaiCompatible('https://api.together.xyz/v1', 'meta-llama/Llama-3-70b', 'Together');
+const queryFireworks = openaiCompatible('https://api.fireworks.ai/inference/v1', 'llama-v3-70b', 'Fireworks');
+const queryXai = openaiCompatible('https://api.x.ai/v1', 'grok-3', 'Grok');
+const queryQwen = openaiCompatible('https://dashscope.aliyuncs.com/compatible-mode/v1', 'qwen-turbo', 'Qwen');
+
+async function queryGemini(prompt, options = {}) {
+  const apiKey = options.apiKey;
+  if (!apiKey) throw new Error('Gemini requires an API key. Set it with /model gemini.');
+
+  const model = options.model || 'gemini-2.0-flash';
+  const body = {
+    contents: [{ parts: [{ text: prompt }] }],
+  };
+
+  const res = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    },
+  );
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Gemini API returned ${res.status}: ${text}`);
+  }
+
+  const response = await res.json();
+  const candidate = response.candidates && response.candidates[0];
+  if (!candidate || !candidate.content || !candidate.content.parts || !candidate.content.parts[0]) {
+    throw new Error('Gemini returned empty response.');
+  }
+  return candidate.content.parts[0].text;
+}
+
+async function queryCohere(prompt, options = {}) {
+  const apiKey = options.apiKey;
+  if (!apiKey) throw new Error('Cohere requires an API key. Set it with /model cohere.');
+
+  const messages = options.messages || [{ role: 'user', content: prompt }];
+  const body = {
+    model: options.model || 'command-r-plus',
+    messages,
+  };
+
+  const res = await fetch('https://api.cohere.com/v2/chat', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Cohere API returned ${res.status}: ${text}`);
+  }
+
+  const response = await res.json();
+  const content = response.message && response.message.content && response.message.content[0];
+  if (!content || content.type !== 'text') throw new Error('Cohere returned empty response.');
+  return content.text;
+}
+
+async function queryAnthropic(prompt, options = {}) {
+  const apiKey = options.apiKey;
+  if (!apiKey) throw new Error('Anthropic requires an API key. Set it with /model anthropic.');
+
+  const messages = options.messages || [{ role: 'user', content: prompt }];
+  const body = {
+    model: options.model || 'claude-sonnet-4-6-20250514',
+    max_tokens: options.maxTokens || 1024,
+    messages,
+  };
+
+  const res = 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(body),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Anthropic API returned ${res.status}: ${text}`);
+  }
+
+  const response = await res.json();
+  const block = response.content && response.content[0];
+  if (!block || block.type !== 'text') throw new Error('Anthropic returned empty response.');
+  return block.text;
+}
+
+async function queryOllama(prompt, options = {}) {
+  const baseUrl = options.baseUrl || 'http://localhost:11434';
+  const messages = options.messages || [{ role: 'user', content: prompt }];
+  const body = {
+    model: options.model || 'llama3',
+    messages,
+    stream: false,
+  };
+
+  const res = await fetch(`${baseUrl}/api/chat`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Ollama API returned ${res.status}: ${text}`);
+  }
+
+  const response = await res.json();
+  if (!response.message || !response.message.content) {
+    throw new Error('Ollama returned empty response.');
+  }
+  return response.message.content;
+}
+
+const QUERY_MAP = {
+  'glm': queryGlmFree,
+  'openai': queryOpenai,
+  'anthropic': queryAnthropic,
+  'ollama': queryOllama,
+  'groq': queryGroq,
+  'deepseek': queryDeepseek,
+  'mistral': queryMistral,
+  'perplexity': queryPerplexity,
+  'openrouter': queryOpenrouter,
+  'together': queryTogether,
+  'fireworks': queryFireworks,
+  'xai': queryXai,
+  'gemini': queryGemini,
+  'cohere': queryCohere,
+  'qwen': queryQwen,
+};
+
+async function queryWithProvider(providerId, prompt, options = {}) {
+  const provider = getProvider(providerId);
+  if (!provider) throw new Error(`Unknown provider: ${providerId}`);
+
+  const queryFn = QUERY_MAP[providerId];
+  if (!queryFn) throw new Error(`Provider ${providerId} not yet implemented`);
+
+  try {
+    return await queryFn(prompt, options);
+  } catch (err) {
+    if (options.fallback && options.fallback !== providerId) {
+      const fallbackFn = QUERY_MAP[options.fallback];
+      if (fallbackFn) return await fallbackFn(prompt, options);
+    }
+    throw err;
+  }
+}
+
+module.exports = { listProviders, getProvider, queryWithProvider };

package/src/integrations/github.js

@@ -0,0 +1,107 @@
+const { Octokit } = require('@octokit/rest');
+const { storeToken, retrieveToken, removeToken } = require('../utils/keychain');
+const { handleGitHubError } = require('../utils/github-error-handler');
+
+function createClient(token) {
+  return new Octokit({ auth: token });
+}
+
+async function validateToken(token) {
+  const octokit = createClient(token);
+  try {
+    const { data } = await octokit.users.getAuthenticated();
+    return { valid: true, user: data };
+  } catch (err) {
+    throw handleGitHubError(err);
+  }
+}
+
+async function connect(token) {
+  const result = await validateToken(token);
+  await storeToken('github', token);
+  return result;
+}
+
+async function disconnect() {
+  return removeToken('github');
+}
+
+async function getClient() {
+  const token = await retrieveToken('github');
+  if (!token) throw new Error('GitHub not connected. Run /connect first.');
+  return createClient(token);
+}
+
+async function listPRs(options = {}) {
+  const octokit = await getClient();
+  try {
+    const { data: user } = await octokit.users.getAuthenticated();
+    const { data } = await octokit.search.issuesAndPullRequests({
+      q: `author:${user.login} is:pr is:open ${options.repo ? `repo:${options.repo}` : ''}`,
+      sort: 'updated',
+      order: 'desc',
+      per_page: options.limit || 20,
+    });
+    return data.items.map(pr => ({
+      number: pr.number,
+      title: pr.title,
+      repo: pr.repository_url.split('/repos/')[1],
+      state: pr.state,
+      url: pr.html_url,
+      updatedAt: pr.updated_at,
+    }));
+  } catch (err) {
+    throw handleGitHubError(err);
+  }
+}
+
+async function createDraftPR(title, options = {}) {
+  const octokit = await getClient();
+  try {
+    const { execSync } = require('child_process');
+    const branch = options.branch || execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
+    const remoteUrl = execSync('git remote get-url origin', { encoding: 'utf8' }).trim();
+    const repoMatch = remoteUrl.match(/[:/]([^/]+\/[^/.]+)/);
+    if (!repoMatch) throw new Error('Could not detect repo from git remote.');
+    const repo = repoMatch[1];
+
+    const base = options.base || 'main';
+    const { data } = await octokit.pulls.create({
+      owner: repo.split('/')[0],
+      repo: repo.split('/')[1],
+      title,
+      head: branch,
+      base,
+      draft: true,
+    });
+    return { number: data.number, url: data.html_url, draft: data.draft };
+  } catch (err) {
+    throw handleGitHubError(err);
+  }
+}
+
+async function commentOnPR(prNumber, message, options = {}) {
+  const octokit = await getClient();
+  try {
+    const repo = options.repo || await detectRepo();
+    const [owner, name] = repo.split('/');
+    const { data } = await octokit.issues.createComment({
+      owner, repo: name, issue_number: prNumber, body: message,
+    });
+    return { id: data.id, url: data.html_url };
+  } catch (err) {
+    throw handleGitHubError(err);
+  }
+}
+
+async function detectRepo() {
+  const { execSync } = require('child_process');
+  const remoteUrl = execSync('git remote get-url origin', { encoding: 'utf8' }).trim();
+  const match = remoteUrl.match(/[:/]([^/]+\/[^/.]+)/);
+  if (!match) throw new Error('Could not detect repo from git remote.');
+  return match[1];
+}
+
+module.exports = {
+  connect, disconnect, getClient, listPRs, createDraftPR, commentOnPR, detectRepo,
+};

package/src/integrations/gitlab.js

@@ -0,0 +1,121 @@
+const { storeToken, retrieveToken, removeToken } = require('../utils/keychain');
+
+/**
+ * GitLab API wrapper — mirrors the pattern from github.js
+ * Uses @gitbeaker/node as API client
+ */
+
+let Gitlab;
+try {
+  Gitlab = require('@gitbeaker/node').Gitlab;
+} catch {
+  // @gitbeaker/node unavailable — API methods will throw
+}
+
+function createClient(token) {
+  if (!Gitlab) throw new Error('Package @gitbeaker/node is not installed. Run: npm install @gitbeaker/node');
+  return new Gitlab({ token });
+}
+
+async function validateToken(token) {
+  const client = createClient(token);
+  try {
+    const user = await client.Users.current();
+    return { valid: true, user };
+  } catch (err) {
+    const message = err.response?.data?.message || err.message;
+    throw new Error(`GitLab token validation failed: ${message}`);
+  }
+}
+
+async function connect(token) {
+  const result = await validateToken(token);
+  await storeToken('gitlab', token);
+  return result;
+}
+
+async function disconnect() {
+  return removeToken('gitlab');
+}
+
+async function getClient() {
+  const token = await retrieveToken('gitlab');
+  if (!token) throw new Error('GitLab not connected. Run /connect gitlab first.');
+  return createClient(token);
+}
+
+async function listMRs(options = {}) {
+  const client = await getClient();
+  try {
+    const mrs = await client.MergeRequests.all({
+      state: 'opened',
+      scope: 'created_by_me',
+      perPage: options.limit || 20,
+    });
+    return mrs.map(mr => ({
+      iid: mr.iid,
+      title: mr.title,
+      projectId: mr.project_id,
+      state: mr.state,
+      url: mr.web_url,
+      updatedAt: mr.updated_at,
+    }));
+  } catch (err) {
+    throw new Error(`Failed to fetch MRs: ${err.message}`);
+  }
+}
+
+async function createDraftMR(title, options = {}) {
+  const client = await getClient();
+  try {
+    const mr = await client.MergeRequests.create(
+      options.projectId,
+      options.sourceBranch || 'main',
+      options.targetBranch || 'main',
+      title,
+      { draft: true },
+    );
+    return { iid: mr.iid, url: mr.web_url, draft: true };
+  } catch (err) {
+    throw new Error(`Failed to create MR: ${err.message}`);
+  }
+}
+
+async function commentOnMR(mrIid, message, options = {}) {
+  const client = await getClient();
+  try {
+    const note = await client.MergeRequestNotes.create(
+      options.projectId,
+      mrIid,
+      message,
+    );
+    return { id: note.id, body: note.body };
+  } catch (err) {
+    throw new Error(`Failed to comment on MR: ${err.message}`);
+  }
+}
+
+async function listIssues(options = {}) {
+  const client = await getClient();
+  try {
+    const issues = await client.Issues.all({
+      state: 'opened',
+      scope: 'created_by_me',
+      perPage: options.limit || 20,
+    });
+    return issues.map(issue => ({
+      iid: issue.iid,
+      title: issue.title,
+      projectId: issue.project_id,
+      state: issue.state,
+      url: issue.web_url,
+      updatedAt: issue.updated_at,
+    }));
+  } catch (err) {
+    throw new Error(`Failed to fetch issues: ${err.message}`);
+  }
+}
+
+module.exports = {
+  connect, disconnect, getClient, listMRs, createDraftMR, commentOnMR, listIssues,
+};

package/src/plugins/context.js

@@ -0,0 +1,64 @@
+const chalk = require('chalk');
+const { readConfig } = require('../config');
+const github = require('../integrations/github');
+
+/**
+ * Safe module loading — returns null when module is unavailable
+ */
+function safeRequire(modulePath) {
+  try {
+    return require(modulePath);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Creates an API wrapper for a given integration (github/gitlab)
+ * Returns null when platform is not connected
+ */
+async function buildPlatformApi(integration, methods) {
+  if (!integration) return null;
+  try {
+    await integration.getClient();
+  } catch {
+    return null;
+  }
+
+  const api = {};
+  for (const method of methods) {
+    if (typeof integration[method] === 'function') {
+      api[method] = (...args) => integration[method](...args);
+    }
+  }
+  return api;
+}
+
+/**
+ * Creates a context object passed to plugins
+ * { config, logger, github, gitlab }
+ */
+async function createPluginContext() {
+  const config = await readConfig();
+
+  const logger = {
+    info: (msg) => console.log(chalk.blue(`  ℹ ${msg}`)),
+    warn: (msg) => console.log(chalk.yellow(`  ⚠ ${msg}`)),
+    error: (msg) => console.log(chalk.red(`  ✖ ${msg}`)),
+    success: (msg) => console.log(chalk.green(`  ✔ ${msg}`)),
+  };
+
+  const gitlab = safeRequire('../integrations/gitlab');
+
+  const githubApi = await buildPlatformApi(github, ['listPRs', 'createDraftPR', 'commentOnPR']);
+  const gitlabApi = await buildPlatformApi(gitlab, ['listMRs', 'createDraftMR', 'commentOnMR']);
+
+  return {
+    config,
+    logger,
+    github: githubApi,
+    gitlab: gitlabApi,
+  };
+}
+
+module.exports = { createPluginContext };

package/src/plugins/loader.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Plugin Loader — discovers and loads .js files from ~/.adm/plugins/
+ *
+ * Each plugin is a CommonJS module exporting:
+ *   { name: string, description: string, execute(args, context): Promise<string> }
+ *
+ * File name minus .js = command name (e.g. audit-deps.js → command audit-deps)
+ */
+function loadPlugins() {
+  const configDir = process.env.ADM_CONFIG_DIR || path.join(require('os').homedir(), '.adm');
+  const pluginsDir = path.join(configDir, 'plugins');
+  const plugins = new Map();
+
+  if (!fs.existsSync(pluginsDir)) {
+    return plugins;
+  }
+
+  const entries = fs.readdirSync(pluginsDir);
+  for (const entry of entries) {
+    if (!entry.endsWith('.js')) continue;
+
+    const filePath = path.join(pluginsDir, entry);
+    const commandName = path.basename(entry, '.js');
+
+    try {
+      const plugin = require(filePath);
+
+      if (!plugin || typeof plugin.execute !== 'function') {
+        console.error(chalk.yellow(`  Plugin "${entry}" skipped — missing execute function.`));
+        continue;
+      }
+
+      plugins.set(commandName, {
+        name: plugin.name || commandName,
+        description: plugin.description || '',
+        execute: plugin.execute,
+      });
+    } catch (err) {
+      console.error(chalk.yellow(`  Plugin "${entry}" skipped — load error: ${err.message}`));
+    }
+  }
+
+  return plugins;
+}
+
+module.exports = { loadPlugins };

package/src/plugins/runner.js

@@ -0,0 +1,25 @@
+const chalk = require('chalk');
+const { loadPlugins } = require('./loader');
+const { createPluginContext } = require('./context');
+
+/**
+ * Tries to run a plugin by name.
+ * Returns string (plugin output) or null when plugin doesn't exist.
+ * Execution errors are handled gracefully — returns error message.
+ */
+async function tryRunPlugin(commandName, args) {
+  const plugins = loadPlugins();
+  const plugin = plugins.get(commandName);
+
+  if (!plugin) return null;
+
+  try {
+    const context = await createPluginContext();
+    const output = await plugin.execute(args || '', context);
+    return output;
+  } catch (err) {
+    return chalk.red(`  Plugin error "${commandName}": ${err.message}`);
+  }
+}
+
+module.exports = { tryRunPlugin };