@plexor-dev/claude-code-plugin-staging 0.1.0-beta.14 → 0.1.0-beta.16

package/commands/plexor-agent.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Agent — set agent autonomy level.
+ *
+ * Agent modes control how the AI agent behaves:
+ *   supervised:         Agent describes actions, waits for your confirmation
+ *   autonomous:         Agent acts independently within safe bounds (default)
+ *   danger-full-auto:   Full autonomy, no guardrails — forces tool execution
+ *
+ * Usage:
+ *   /plexor-agent                      Show current agent mode
+ *   /plexor-agent supervised           Confirm before every action
+ *   /plexor-agent autonomous           Smart autonomy (default)
+ *   /plexor-agent danger-full-auto     No guardrails
+ */
+
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
+
+const VALID = ['supervised', 'autonomous', 'danger-full-auto'];
+const DESC = {
+  supervised:         'Confirm before acting',
+  autonomous:         'Acts within safe bounds (default)',
+  'danger-full-auto': 'Full autonomy, no guardrails'
+};
+const ALIASES = {
+  auto: 'autonomous',
+  fullauto: 'danger-full-auto',
+  'full-auto': 'danger-full-auto',
+  full_auto: 'danger-full-auto',
+  danger: 'danger-full-auto'
+};
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const current = readSetting(config, 'orchestrationMode', 'orchestration_mode', 'PLEXOR_ORCHESTRATION_MODE', VALID, 'autonomous');
+
+  if (args.length === 0) {
+    console.log(`Agent Mode: ${current.value} (${current.source})`);
+    console.log(`  ${DESC[current.value]}`);
+    console.log('');
+    console.log('Options:');
+    for (const v of VALID) {
+      const marker = v === current.value ? '>>' : '  ';
+      console.log(`  ${marker} ${v.padEnd(20)} ${DESC[v]}`);
+    }
+    console.log('');
+    console.log('Set: /plexor-agent <mode>');
+    return;
+  }
+
+  let requested = args[0].toLowerCase().trim();
+  if (ALIASES[requested]) requested = ALIASES[requested];
+
+  if (!VALID.includes(requested)) {
+    console.error(`Invalid agent mode: "${args[0]}"`);
+    console.error(`Valid: ${VALID.join(', ')}`);
+    process.exit(1);
+  }
+
+  if (current.source === 'environment' && requested !== current.value) {
+    console.log(`Warning: PLEXOR_ORCHESTRATION_MODE env var is set to "${current.value}". Config updated but env var takes priority.`);
+  }
+
+  if (requested === current.value && current.source === 'config') {
+    console.log(`Already set to "${requested}".`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.orchestrationMode = requested;
+  if (config.settings.orchestration_mode) delete config.settings.orchestration_mode;
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`Agent mode: ${current.value} → ${requested}`);
+  console.log(`  ${DESC[requested]}`);
+  if (requested === 'danger-full-auto') {
+    console.log('  Warning: This forces tool execution on every turn with tools.');
+  }
+  console.log('  Takes effect on next request.');
+}
+
+main();

package/commands/plexor-agent.md

@@ -0,0 +1,36 @@
+---
+description: Set Plexor agent autonomy — supervised, autonomous, or danger-full-auto (user)
+---
+
+**Step 1: Check if arguments were provided.**
+
+If `$ARGUMENTS` contains a value (e.g., `/plexor-agent autonomous`), apply it directly:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-agent.js $ARGUMENTS
+```
+
+Present the output to the user and STOP. Do NOT call any other tools.
+
+**Step 2: If NO arguments were provided** (just `/plexor-agent`), first show the current state:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-agent.js
+```
+
+Then immediately use **AskUserQuestion** to let the user pick a mode:
+
+- **Question**: "Which agent autonomy mode?"
+- **Header**: "Agent mode"
+- **Options** (exactly 3):
+  1. **supervised** — "Confirm before every action"
+  2. **autonomous (Recommended)** — "Acts within safe bounds, default mode"
+  3. **danger-full-auto** — "Full autonomy, no guardrails"
+
+**Step 3: After the user selects**, apply their choice:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-agent.js <selected_value>
+```
+
+Present the output and STOP. Do NOT re-execute commands or call other tools.

package/commands/plexor-provider.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Provider — select which LLM provider to use.
+ *
+ * Provider options:
+ *   auto:       Best model for task (router decides, default)
+ *   anthropic:  Claude (Anthropic)
+ *   openai:     GPT (OpenAI)
+ *   deepseek:   DeepSeek
+ *   mistral:    Mistral
+ *   gemini:     Gemini (Google)
+ *   grok:       Grok (xAI)
+ *   cohere:     Command-R (Cohere)
+ *
+ * Usage:
+ *   /plexor-provider              Show current provider
+ *   /plexor-provider auto         Let router decide (default)
+ *   /plexor-provider anthropic    Force Claude
+ *   /plexor-provider openai       Force GPT
+ */
+
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
+
+const VALID = ['auto', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini', 'grok', 'cohere'];
+const DESC = {
+  auto:      'Best model for task (router decides)',
+  anthropic: 'Claude (Anthropic)',
+  openai:    'GPT (OpenAI)',
+  deepseek:  'DeepSeek',
+  mistral:   'Mistral',
+  gemini:    'Gemini (Google)',
+  grok:      'Grok (xAI)',
+  cohere:    'Command-R (Cohere)'
+};
+const ALIASES = { claude: 'anthropic' };
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const current = readSetting(config, 'preferred_provider', null, 'PLEXOR_PROVIDER', VALID, 'auto');
+
+  if (args.length === 0) {
+    console.log(`Provider: ${current.value} (${current.source})`);
+    console.log(`  ${DESC[current.value]}`);
+    console.log('');
+    console.log('Options:');
+    for (const v of VALID) {
+      const marker = v === current.value ? '>>' : '  ';
+      console.log(`  ${marker} ${v.padEnd(12)} ${DESC[v]}`);
+    }
+    console.log('');
+    console.log('Set: /plexor-provider <name>');
+    return;
+  }
+
+  let requested = args[0].toLowerCase().trim();
+  if (ALIASES[requested]) requested = ALIASES[requested];
+
+  if (!VALID.includes(requested)) {
+    console.error(`Invalid provider: "${args[0]}"`);
+    console.error(`Valid: ${VALID.join(', ')}`);
+    process.exit(1);
+  }
+
+  if (current.source === 'environment' && requested !== current.value) {
+    console.log(`Warning: PLEXOR_PROVIDER env var is set to "${current.value}". Config updated but env var takes priority.`);
+  }
+
+  if (requested === current.value && current.source === 'config') {
+    console.log(`Already set to "${requested}".`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.preferred_provider = requested;
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`Provider: ${current.value} → ${requested}`);
+  console.log(`  ${DESC[requested]}`);
+  console.log('  Takes effect on next request.');
+}
+
+main();

package/commands/plexor-provider.md

@@ -0,0 +1,37 @@
+---
+description: Set Plexor LLM provider — auto, anthropic, openai, deepseek, gemini, etc. (user)
+---
+
+**Step 1: Check if arguments were provided.**
+
+If `$ARGUMENTS` contains a value (e.g., `/plexor-provider anthropic`), apply it directly:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js $ARGUMENTS
+```
+
+Present the output to the user and STOP. Do NOT call any other tools.
+
+**Step 2: If NO arguments were provided** (just `/plexor-provider`), first show the current state:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js
+```
+
+Then immediately use **AskUserQuestion** to let the user pick a provider:
+
+- **Question**: "Which LLM provider?"
+- **Header**: "Provider"
+- **Options** (exactly 4 — "Other" auto-covers mistral, gemini, grok, cohere):
+  1. **auto (Recommended)** — "Let Plexor choose the best provider automatically"
+  2. **anthropic** — "Claude models (Opus, Sonnet, Haiku)"
+  3. **openai** — "GPT models (GPT-4o, GPT-4.1, o1)"
+  4. **deepseek** — "DeepSeek models (Chat, Reasoner)"
+
+**Step 3: After the user selects**, apply their choice. If the user picks "Other", they will type the provider name (mistral, gemini, grok, cohere):
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-provider.js <selected_value>
+```
+
+Present the output and STOP. Do NOT re-execute commands or call other tools.

package/commands/plexor-routing.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Routing — set the cost/quality routing mode.
+ *
+ * Routing modes control how aggressively Plexor optimizes for cost:
+ *   eco:         60-90% savings, cheapest models
+ *   balanced:    40-60% savings, good balance (default)
+ *   quality:     20-40% savings, premium models
+ *   passthrough: No optimization, direct to provider
+ *
+ * Usage:
+ *   /plexor-routing              Show current routing mode
+ *   /plexor-routing eco          Set to eco (maximum savings)
+ *   /plexor-routing balanced     Set to balanced
+ *   /plexor-routing quality      Set to quality
+ *   /plexor-routing passthrough  Set to passthrough (no optimization)
+ */
+
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
+
+const VALID = ['eco', 'balanced', 'quality', 'passthrough'];
+const DESC = {
+  eco:         '60-90% savings, cheapest models',
+  balanced:    '40-60% savings, good balance',
+  quality:     '20-40% savings, premium models',
+  passthrough: 'No optimization, direct to provider'
+};
+const ALIASES = { cost: 'eco' };
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+  const current = readSetting(config, 'mode', null, 'PLEXOR_MODE', VALID, 'balanced');
+
+  if (args.length === 0) {
+    console.log(`Routing Mode: ${current.value} (${current.source})`);
+    console.log(`  ${DESC[current.value]}`);
+    console.log('');
+    console.log('Options:');
+    for (const v of VALID) {
+      const marker = v === current.value ? '>>' : '  ';
+      console.log(`  ${marker} ${v.padEnd(14)} ${DESC[v]}`);
+    }
+    console.log('');
+    console.log('Set: /plexor-routing <mode>');
+    return;
+  }
+
+  let requested = args[0].toLowerCase().trim();
+  if (ALIASES[requested]) requested = ALIASES[requested];
+
+  if (!VALID.includes(requested)) {
+    console.error(`Invalid routing mode: "${args[0]}"`);
+    console.error(`Valid: ${VALID.join(', ')}`);
+    process.exit(1);
+  }
+
+  if (current.source === 'environment' && requested !== current.value) {
+    console.log(`Warning: PLEXOR_MODE env var is set to "${current.value}". Config updated but env var takes priority.`);
+  }
+
+  if (requested === current.value && current.source === 'config') {
+    console.log(`Already set to "${requested}".`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings.mode = requested;
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`Routing mode: ${current.value} → ${requested}`);
+  console.log(`  ${DESC[requested]}`);
+  console.log('  Takes effect on next request.');
+}
+
+main();

package/commands/plexor-routing.md

@@ -0,0 +1,37 @@
+---
+description: Set Plexor routing mode — eco, balanced, quality, or passthrough (user)
+---
+
+**Step 1: Check if arguments were provided.**
+
+If `$ARGUMENTS` contains a value (e.g., `/plexor-routing eco`), apply it directly:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-routing.js $ARGUMENTS
+```
+
+Present the output to the user and STOP. Do NOT call any other tools.
+
+**Step 2: If NO arguments were provided** (just `/plexor-routing`), first show the current state:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-routing.js
+```
+
+Then immediately use **AskUserQuestion** to let the user pick a mode:
+
+- **Question**: "Which routing mode?"
+- **Header**: "Routing"
+- **Options** (exactly 4):
+  1. **eco (Recommended)** — "Cheapest models first, best cost efficiency"
+  2. **balanced** — "Balance cost and quality, smart model selection"
+  3. **quality** — "Premium models, best output quality"
+  4. **passthrough** — "Direct provider access, no routing logic"
+
+**Step 3: After the user selects**, apply their choice:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-routing.js <selected_value>
+```
+
+Present the output and STOP. Do NOT re-execute commands or call other tools.

package/commands/plexor-settings.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+/**
+ * Plexor Settings — unified dashboard for all Plexor configuration.
+ *
+ * Usage:
+ *   /plexor-settings                          Show all settings
+ *   /plexor-settings routing <value>          Set routing mode
+ *   /plexor-settings agent <value>            Set agent autonomy
+ *   /plexor-settings provider <value>         Set LLM provider
+ */
+
+const { loadConfig, saveConfig, readSetting } = require('../lib/config-utils');
+
+// ── Definitions ──────────────────────────────────────────────────────────────
+
+const ROUTING_MODES = ['eco', 'balanced', 'quality', 'passthrough'];
+const ROUTING_DESC = {
+  eco:         '60-90% savings, cheapest models',
+  balanced:    '40-60% savings, good balance',
+  quality:     '20-40% savings, premium models',
+  passthrough: 'No optimization, direct to provider'
+};
+const ROUTING_ALIASES = { cost: 'eco' };
+
+const AGENT_MODES = ['supervised', 'autonomous', 'danger-full-auto'];
+const AGENT_DESC = {
+  supervised:         'Confirm before acting',
+  autonomous:         'Acts within safe bounds',
+  'danger-full-auto': 'Full autonomy, no guardrails'
+};
+const AGENT_ALIASES = { auto: 'autonomous', fullauto: 'danger-full-auto', 'full-auto': 'danger-full-auto', full_auto: 'danger-full-auto' };
+
+const PROVIDERS = ['auto', 'anthropic', 'openai', 'deepseek', 'mistral', 'gemini', 'grok', 'cohere'];
+const PROVIDER_DESC = {
+  auto:      'Best model for task (router decides)',
+  anthropic: 'Claude (Anthropic)',
+  openai:    'GPT (OpenAI)',
+  deepseek:  'DeepSeek',
+  mistral:   'Mistral',
+  gemini:    'Gemini (Google)',
+  grok:      'Grok (xAI)',
+  cohere:    'Command-R (Cohere)'
+};
+const PROVIDER_ALIASES = { claude: 'anthropic' };
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function pad(s, n) { return String(s).padEnd(n); }
+
+function showDashboard(config) {
+  const routing  = readSetting(config, 'mode', null, 'PLEXOR_MODE', ROUTING_MODES, 'balanced');
+  const agent    = readSetting(config, 'orchestrationMode', 'orchestration_mode', 'PLEXOR_ORCHESTRATION_MODE', AGENT_MODES, 'autonomous');
+  const provider = readSetting(config, 'preferred_provider', null, 'PLEXOR_PROVIDER', PROVIDERS, 'auto');
+
+  const W = 56;
+  const line = '─'.repeat(W - 2);
+  const row = (label, val, desc, src) => {
+    const marker = `${val} (${src})`;
+    console.log(`│ ${pad(label, 10)} ${pad(marker, 28)} ${pad(desc, W - 43)}│`);
+  };
+
+  console.log(`┌${line}┐`);
+  console.log(`│${pad('  Plexor Settings', W - 2)}│`);
+  console.log(`├${line}┤`);
+  row('routing', routing.value, ROUTING_DESC[routing.value], routing.source);
+  row('agent', agent.value, AGENT_DESC[agent.value], agent.source);
+  row('provider', provider.value, PROVIDER_DESC[provider.value], provider.source);
+  console.log(`├${line}┤`);
+  console.log(`│${pad('  Set:', W - 2)}│`);
+  console.log(`│${pad('    /plexor-settings routing eco', W - 2)}│`);
+  console.log(`│${pad('    /plexor-settings agent danger-full-auto', W - 2)}│`);
+  console.log(`│${pad('    /plexor-settings provider anthropic', W - 2)}│`);
+  console.log(`├${line}┤`);
+  console.log(`│${pad('  Shortcuts:', W - 2)}│`);
+  console.log(`│${pad('    /plexor-routing   /plexor-agent   /plexor-provider', W - 2)}│`);
+  console.log(`└${line}┘`);
+}
+
+function setDimension(dimension, value, config) {
+  let validValues, aliases, configKey, configKeyAlt, envVar, defaultVal, descMap, label;
+
+  switch (dimension) {
+    case 'routing':
+    case 'mode':
+      validValues = ROUTING_MODES; aliases = ROUTING_ALIASES;
+      configKey = 'mode'; configKeyAlt = null; envVar = 'PLEXOR_MODE';
+      defaultVal = 'balanced'; descMap = ROUTING_DESC; label = 'Routing Mode';
+      break;
+    case 'agent':
+    case 'orchestration':
+      validValues = AGENT_MODES; aliases = AGENT_ALIASES;
+      configKey = 'orchestrationMode'; configKeyAlt = 'orchestration_mode'; envVar = 'PLEXOR_ORCHESTRATION_MODE';
+      defaultVal = 'autonomous'; descMap = AGENT_DESC; label = 'Agent Mode';
+      break;
+    case 'provider':
+      validValues = PROVIDERS; aliases = PROVIDER_ALIASES;
+      configKey = 'preferred_provider'; configKeyAlt = null; envVar = 'PLEXOR_PROVIDER';
+      defaultVal = 'auto'; descMap = PROVIDER_DESC; label = 'Provider';
+      break;
+    default:
+      console.error(`Unknown setting: "${dimension}"`);
+      console.error('Valid settings: routing, agent, provider');
+      process.exit(1);
+  }
+
+  let resolved = (value || '').toLowerCase().trim();
+  if (aliases[resolved]) resolved = aliases[resolved];
+
+  if (!validValues.includes(resolved)) {
+    console.error(`Invalid ${dimension} value: "${value}"`);
+    console.error(`Valid values: ${validValues.join(', ')}`);
+    process.exit(1);
+  }
+
+  const current = readSetting(config, configKey, configKeyAlt, envVar, validValues, defaultVal);
+
+  if (current.source === 'environment' && resolved !== current.value) {
+    console.log(`Warning: ${envVar} environment variable is set to "${current.value}".`);
+    console.log(`Config will be updated, but env var takes priority.`);
+  }
+
+  if (resolved === current.value && current.source === 'config') {
+    console.log(`${label} is already set to "${resolved}".`);
+    return;
+  }
+
+  config.settings = config.settings || {};
+  config.settings[configKey] = resolved;
+  if (configKeyAlt && config.settings[configKeyAlt]) {
+    delete config.settings[configKeyAlt];
+  }
+
+  if (!saveConfig(config)) { process.exit(1); }
+
+  console.log(`${label} updated: ${current.value} → ${resolved}`);
+  console.log(`  ${descMap[resolved]}`);
+  console.log(`  Takes effect on next request.`);
+}
+
+// ── Main ─────────────────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = loadConfig();
+
+  if (args.length === 0) {
+    showDashboard(config);
+    return;
+  }
+
+  if (args.length === 1) {
+    // Show one dimension's current value + options
+    const dim = args[0].toLowerCase();
+    let validValues, descMap, configKey, configKeyAlt, envVar, defaultVal, label;
+    switch (dim) {
+      case 'routing': case 'mode':
+        validValues = ROUTING_MODES; descMap = ROUTING_DESC;
+        configKey = 'mode'; configKeyAlt = null; envVar = 'PLEXOR_MODE';
+        defaultVal = 'balanced'; label = 'Routing Mode'; break;
+      case 'agent': case 'orchestration':
+        validValues = AGENT_MODES; descMap = AGENT_DESC;
+        configKey = 'orchestrationMode'; configKeyAlt = 'orchestration_mode'; envVar = 'PLEXOR_ORCHESTRATION_MODE';
+        defaultVal = 'autonomous'; label = 'Agent Mode'; break;
+      case 'provider':
+        validValues = PROVIDERS; descMap = PROVIDER_DESC;
+        configKey = 'preferred_provider'; configKeyAlt = null; envVar = 'PLEXOR_PROVIDER';
+        defaultVal = 'auto'; label = 'Provider'; break;
+      default:
+        console.error(`Unknown setting: "${dim}". Valid: routing, agent, provider`);
+        process.exit(1);
+    }
+    const current = readSetting(config, configKey, configKeyAlt, envVar, validValues, defaultVal);
+    console.log(`${label}: ${current.value} (${current.source})`);
+    console.log('Options:');
+    for (const v of validValues) {
+      const marker = v === current.value ? '>>' : '  ';
+      console.log(`  ${marker} ${v.padEnd(18)} ${descMap[v]}`);
+    }
+    return;
+  }
+
+  setDimension(args[0], args[1], config);
+}
+
+main();

package/commands/plexor-settings.md

@@ -0,0 +1,52 @@
+---
+description: View and change Plexor settings — routing mode, agent autonomy, LLM provider (user)
+---
+
+**Step 1: Check if arguments were provided.**
+
+If `$ARGUMENTS` contains both a dimension AND a value (e.g., `/plexor-settings routing eco`), apply it directly:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-settings.js $ARGUMENTS
+```
+
+Present the output to the user and STOP. Do NOT call any other tools.
+
+**Step 2: If only a dimension was provided** (e.g., `/plexor-settings routing`), show current state then present a picker for that dimension:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-settings.js $ARGUMENTS
+```
+
+Then use **AskUserQuestion** based on which dimension:
+
+**If dimension is "routing":**
+- **Question**: "Which routing mode?"
+- **Header**: "Routing"
+- **Options**: eco (Recommended) — "Cheapest first", balanced — "Cost/quality balance", quality — "Premium models", passthrough — "Direct access"
+
+**If dimension is "agent":**
+- **Question**: "Which agent autonomy mode?"
+- **Header**: "Agent mode"
+- **Options**: supervised — "Confirm every action", autonomous (Recommended) — "Safe bounds", danger-full-auto — "No guardrails"
+
+**If dimension is "provider":**
+- **Question**: "Which LLM provider?"
+- **Header**: "Provider"
+- **Options**: auto (Recommended) — "Auto-select", anthropic — "Claude models", openai — "GPT models", deepseek — "DeepSeek models"
+
+After the user selects, apply:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-settings.js <dimension> <selected_value>
+```
+
+Present the output and STOP.
+
+**Step 3: If NO arguments were provided** (just `/plexor-settings`), show the dashboard:
+
+```bash
+node ~/.claude/plugins/plexor/commands/plexor-settings.js
+```
+
+Present the output to the user and STOP. Do NOT call any other tools.