helix-assistant-cli 0.2.14 → 0.6.0

package/src/commands/memory.ts

@@ -0,0 +1,167 @@
+/**
+ * /memory — CLI command for inspecting the Adaptive Learning Harness.
+ *
+ * Subcommands:
+ *   /memory           — show quick stats summary
+ *   /memory stats     — detailed episode + rule counts
+ *   /memory rules     — list top learned rules
+ *   /memory reset     — run maintenance / pruning cycle
+ */
+import chalk from 'chalk';
+import type { AgentClient } from '../client/agent-client';
+import { GREEN, YELLOW, RED, GRAY, DIM, BOLD, ORANGE_BOLD, CYAN } from '../ui/colors';
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+interface LearnedRule {
+  category: string;
+  rule: string;
+  confidence: number;
+  uses: number;
+}
+
+interface LearningStats {
+  episode_count: number;
+  rule_count: number;
+  correction_count: number;
+  skill_count: number;
+  top_rules: LearnedRule[];
+  last_episode_at?: string;
+  user_md_exists: boolean;
+}
+
+// ── Request helper ────────────────────────────────────────────────────────────
+
+type RequestableClient = AgentClient & {
+  request: <T>(type: string, payload: unknown) => Promise<T>;
+};
+
+async function fetchLearningStats(client: AgentClient): Promise<LearningStats | null> {
+  try {
+    return await (client as RequestableClient).request<LearningStats>('GET_LEARNING_STATS', {});
+  } catch {
+    return null;
+  }
+}
+
+// ── Renderers ─────────────────────────────────────────────────────────────────
+
+function renderStats(stats: LearningStats): void {
+  console.log('');
+  console.log(`  ${chalk.hex('#FF8C00').bold('⬡ Sistema de Aprendizaje Adaptativo')}`);
+  console.log(`  ${chalk.gray('─'.repeat(48))}`);
+
+  const ep = stats.episode_count;
+  const ru = stats.rule_count;
+  const co = stats.correction_count;
+  const sk = stats.skill_count;
+
+  console.log(`  ${chalk.gray('Episodios registrados')}   ${chalk.white.bold(ep.toString())}`);
+  console.log(`  ${chalk.gray('Correcciones del usuario')} ${co > 0 ? chalk.yellow.bold(co.toString()) : chalk.white(co.toString())}`);
+  console.log(`  ${chalk.gray('Reglas aprendidas')}       ${chalk.cyan.bold(ru.toString())}`);
+  console.log(`  ${chalk.gray('Skills auto-generadas')}   ${chalk.magenta.bold(sk.toString())}`);
+
+  if (stats.last_episode_at) {
+    const d = new Date(stats.last_episode_at);
+    console.log(`  ${chalk.gray('Último episodio')}         ${DIM(d.toLocaleString())}`);
+  }
+
+  const userMdStatus = stats.user_md_exists
+    ? chalk.green('✔ USER.md activo')
+    : chalk.gray('○ Sin perfil generado aún');
+  console.log(`  ${chalk.gray('Perfil feedforward')}      ${userMdStatus}`);
+  console.log('');
+}
+
+function renderRules(stats: LearningStats): void {
+  if (!stats.top_rules || stats.top_rules.length === 0) {
+    console.log(GRAY('  No hay reglas aprendidas todavía. Interactúa con HELIX para que aprenda tus preferencias.\n'));
+    return;
+  }
+
+  console.log('');
+  console.log(`  ${chalk.hex('#FF8C00').bold(`✦ Top ${stats.top_rules.length} Reglas Aprendidas`)}`);
+  console.log(`  ${chalk.gray('─'.repeat(56))}`);
+
+  for (const rule of stats.top_rules) {
+    const conf = Math.round(rule.confidence * 100);
+    const bar = '█'.repeat(Math.min(10, Math.floor(conf / 10)));
+    const confColor = conf >= 80 ? chalk.green : conf >= 50 ? chalk.yellow : chalk.gray;
+    console.log(`  ${chalk.cyan(`[${rule.category}]`).padEnd(24)} ${chalk.white(rule.rule)}`);
+    console.log(`    ${DIM('Confianza:')} ${confColor(`${conf}%`)} ${chalk.gray(bar)}  ${DIM(`(${rule.uses} usos)`)}`);
+    console.log('');
+  }
+}
+
+// ── Command handlers ──────────────────────────────────────────────────────────
+
+export async function handleMemoryStats(client: AgentClient): Promise<void> {
+  const stats = await fetchLearningStats(client);
+
+  if (!stats) {
+    console.log(YELLOW('  ⚠ El harness de aprendizaje no está disponible (agente desconectado o versión antigua).\n'));
+    return;
+  }
+
+  renderStats(stats);
+  if (stats.top_rules?.length) {
+    console.log(DIM('  Usa /memory rules para ver las reglas detalladas.'));
+    console.log('');
+  }
+}
+
+export async function handleMemoryRules(client: AgentClient): Promise<void> {
+  const stats = await fetchLearningStats(client);
+
+  if (!stats) {
+    console.log(YELLOW('  ⚠ El harness de aprendizaje no está disponible.\n'));
+    return;
+  }
+
+  renderStats(stats);
+  renderRules(stats);
+}
+
+export async function handleMemoryReset(client: AgentClient): Promise<void> {
+  try {
+    const result = await (client as RequestableClient).request<{ pruned_rules_count: number; pruned_skills: string[] }>(
+      'RUN_LEARNING_MAINTENANCE',
+      {},
+    );
+
+    console.log('');
+    console.log(GREEN('  ✔ Mantenimiento del harness completado.'));
+    console.log(`  ${chalk.gray('Reglas podadas:')}  ${chalk.white.bold(String(result.pruned_rules_count ?? 0))}`);
+    const pruned = result.pruned_skills ?? [];
+    if (pruned.length) {
+      console.log(`  ${chalk.gray('Skills podadas:')} ${chalk.white(pruned.join(', '))}`);
+    } else {
+      console.log(`  ${chalk.gray('Skills podadas:')} ${DIM('ninguna')}`);
+    }
+    console.log('');
+  } catch (err) {
+    console.log(RED(`  ✖ Error durante mantenimiento: ${(err as Error).message}\n`));
+  }
+}
+
+/** Top-level dispatcher for /memory <args> */
+export async function handleMemoryCommand(client: AgentClient, args: string): Promise<void> {
+  const sub = args.trim().split(/\s+/)[0]?.toLowerCase() || '';
+
+  switch (sub) {
+    case '':
+    case 'stats':
+      await handleMemoryStats(client);
+      break;
+    case 'rules':
+      await handleMemoryRules(client);
+      break;
+    case 'reset':
+    case 'maintenance':
+    case 'prune':
+      await handleMemoryReset(client);
+      break;
+    default:
+      console.log(YELLOW(`  Subcomando desconocido: "${sub}". Opciones: stats, rules, reset\n`));
+  }
+}

package/src/commands/model.ts

@@ -0,0 +1,237 @@
+/**
+ * /model — CLI command for viewing and switching the active AI model.
+ *
+ * Subcommands:
+ *   /model            — show current model + provider
+ *   /model list       — list all model tiers (Free, Local Ollama, Cloud)
+ *   /model set <id>   — switch to a model by id
+ *   /model effort <low|medium|high> — set effort/quality level
+ */
+import chalk from 'chalk';
+import type { AgentClient } from '../client/agent-client';
+import { CYAN, CYAN_BOLD, GREEN, YELLOW, GRAY, DIM, BOLD, ORANGE_BOLD, RED } from '../ui/colors';
+
+// ── Model catalog (mirrors ModelSelectorDropdown.tsx) ──────────────────────────
+export interface ModelEntry {
+  id: string;
+  label: string;
+  tier: 'free' | 'local' | 'cloud';
+  provider: string;
+  badge?: string;
+}
+
+export const FREE_MODELS: ModelEntry[] = [
+  {
+    id: 'meta-llama/llama-3.2-3b-instruct:free',
+    label: 'Llama 3.2 3B Instruct',
+    tier: 'free',
+    provider: 'free',
+    badge: '0-cost',
+  },
+  {
+    id: 'qwen/qwen-2.5-coder-32b-instruct:free',
+    label: 'Qwen 2.5 Coder 32B',
+    tier: 'free',
+    provider: 'free',
+    badge: '0-cost',
+  },
+  {
+    id: 'deepseek/deepseek-r1:free',
+    label: 'DeepSeek R1',
+    tier: 'free',
+    provider: 'free',
+    badge: '0-cost · razonamiento',
+  },
+  {
+    id: 'google/gemini-flash-1.5:free',
+    label: 'Gemini Flash 1.5',
+    tier: 'free',
+    provider: 'free',
+    badge: '0-cost · rápido',
+  },
+];
+
+export const LOCAL_MODELS: ModelEntry[] = [
+  { id: 'ollama/llama3', label: 'Llama 3 (local)', tier: 'local', provider: 'ollama' },
+  { id: 'ollama/mistral', label: 'Mistral 7B (local)', tier: 'local', provider: 'ollama' },
+  { id: 'ollama/deepseek-coder', label: 'DeepSeek Coder (local)', tier: 'local', provider: 'ollama' },
+  { id: 'ollama/phi3', label: 'Phi-3 Mini (local)', tier: 'local', provider: 'ollama' },
+  { id: 'ollama/qwen2.5-coder', label: 'Qwen 2.5 Coder (local)', tier: 'local', provider: 'ollama' },
+];
+
+export const CLOUD_MODELS: ModelEntry[] = [
+  { id: 'gpt-4o', label: 'GPT-4o', tier: 'cloud', provider: 'openai' },
+  { id: 'gpt-4o-mini', label: 'GPT-4o Mini', tier: 'cloud', provider: 'openai' },
+  { id: 'claude-3-5-sonnet-20241022', label: 'Claude 3.5 Sonnet', tier: 'cloud', provider: 'anthropic' },
+  { id: 'claude-3-haiku-20240307', label: 'Claude 3 Haiku', tier: 'cloud', provider: 'anthropic' },
+  { id: 'gemini-1.5-pro', label: 'Gemini 1.5 Pro', tier: 'cloud', provider: 'gemini' },
+  { id: 'gemini-1.5-flash', label: 'Gemini 1.5 Flash', tier: 'cloud', provider: 'gemini' },
+];
+
+export const ALL_MODELS: ModelEntry[] = [...FREE_MODELS, ...LOCAL_MODELS, ...CLOUD_MODELS];
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function providerBadge(entry: ModelEntry): string {
+  if (entry.tier === 'free') return chalk.green.bold('[0-COST]');
+  if (entry.tier === 'local') return chalk.cyan.bold('[LOCAL]');
+  return chalk.yellow.bold('[CLOUD]');
+}
+
+function findModel(id: string): ModelEntry | undefined {
+  return ALL_MODELS.find((m) => m.id === id || m.id.startsWith(id));
+}
+
+// ── Command handlers ──────────────────────────────────────────────────────────
+
+/** /model — show current model */
+export async function handleModelStatus(client: AgentClient): Promise<void> {
+  try {
+    const settings = await client.getSettings();
+    const modelId: string = (settings as Record<string, string>).default_model || '(none)';
+    const provider: string = (settings as Record<string, string>).preferred_provider || '(none)';
+    const entry = findModel(modelId);
+
+    console.log('');
+    console.log(`  ${chalk.hex('#FF8C00').bold('⬡ Modelo Activo')}`);
+    console.log(`  ${chalk.gray('─'.repeat(44))}`);
+    console.log(`  ${chalk.gray('ID')}           ${chalk.white.bold(modelId)}`);
+    console.log(`  ${chalk.gray('Proveedor')}    ${chalk.white(provider)}`);
+    if (entry) {
+      console.log(`  ${chalk.gray('Nombre')}       ${entry.label}`);
+      console.log(`  ${chalk.gray('Nivel')}        ${providerBadge(entry)} ${entry.badge ? DIM(`(${entry.badge})`) : ''}`);
+    }
+    const speed: string = (settings as Record<string, string>).speed_preference || 'balanced';
+    const quality: string = (settings as Record<string, string>).quality_preference || 'balanced';
+    console.log(`  ${chalk.gray('Velocidad')}    ${chalk.cyan(speed)}`);
+    console.log(`  ${chalk.gray('Calidad')}      ${chalk.cyan(quality)}`);
+    console.log('');
+    console.log(DIM('  Usa /model list para ver opciones, /model set <id> para cambiar.'));
+    console.log('');
+  } catch (err) {
+    console.log(RED(`  Error al obtener modelo: ${(err as Error).message}\n`));
+  }
+}
+
+/** /model list — print the full model catalog */
+export function handleModelList(): void {
+  const printSection = (title: string, models: ModelEntry[]): void => {
+    console.log(`\n  ${chalk.hex('#FF8C00').bold(title)}`);
+    console.log(`  ${chalk.gray('─'.repeat(60))}`);
+    for (const m of models) {
+      const badge = providerBadge(m);
+      const extra = m.badge ? DIM(` · ${m.badge}`) : '';
+      console.log(`  ${badge}  ${chalk.white.bold(m.label.padEnd(32))} ${GRAY(m.id)}${extra}`);
+    }
+  };
+
+  console.log('');
+  console.log(`  ${BOLD('🧠 Catálogo de Modelos HELIX')}`);
+  printSection('✦ Nivel 1 — Sin costo (OpenRouter Free)', FREE_MODELS);
+  printSection('✦ Nivel 2 — Local Ollama (sin internet)', LOCAL_MODELS);
+  printSection('✦ Nivel 3 — Nube con API Key propia', CLOUD_MODELS);
+  console.log('');
+  console.log(DIM('  Usa: /model set <model-id>   para activar un modelo'));
+  console.log(DIM('  Usa: /model effort <low|medium|high>   para ajustar esfuerzo'));
+  console.log('');
+}
+
+/** /model set <id> — switch the active model */
+export async function handleModelSet(client: AgentClient, modelId: string): Promise<void> {
+  if (!modelId) {
+    console.log(YELLOW('  Uso: /model set <model-id>\n'));
+    return;
+  }
+
+  const entry = findModel(modelId);
+  const provider = entry?.provider || (modelId.startsWith('ollama/') ? 'ollama' : 'openai');
+
+  try {
+    await client.saveSettings({
+      default_model: entry?.id ?? modelId,
+      preferred_provider: provider,
+    } as Parameters<typeof client.saveSettings>[0]);
+
+    const badge = entry ? providerBadge(entry) : '';
+    console.log('');
+    console.log(GREEN('  ✔ Modelo actualizado correctamente.'));
+    console.log(`  ${chalk.gray('Modelo:')}    ${chalk.white.bold(entry?.id ?? modelId)} ${badge}`);
+    console.log(`  ${chalk.gray('Proveedor:')} ${chalk.white(provider)}`);
+    console.log('');
+  } catch (err) {
+    console.log(RED(`  ✖ Error al cambiar modelo: ${(err as Error).message}\n`));
+  }
+}
+
+/** /model effort <low|medium|high> — set effort/quality level */
+export async function handleModelEffort(client: AgentClient, level: string): Promise<void> {
+  const valid = ['low', 'medium', 'high'];
+  const normalized = level?.toLowerCase();
+  if (!normalized || !valid.includes(normalized)) {
+    console.log(YELLOW('  Uso: /model effort <low|medium|high>\n'));
+    return;
+  }
+
+  const speedMap: Record<string, string> = { low: 'fast', medium: 'balanced', high: 'balanced' };
+  const qualityMap: Record<string, string> = { low: 'fast', medium: 'balanced', high: 'best' };
+
+  try {
+    await client.saveSettings({
+      speed_preference: speedMap[normalized],
+      quality_preference: qualityMap[normalized],
+    } as Parameters<typeof client.saveSettings>[0]);
+
+    console.log('');
+    console.log(GREEN(`  ✔ Nivel de esfuerzo → ${chalk.white.bold(normalized.toUpperCase())}`));
+    console.log(DIM(`  Velocidad: ${speedMap[normalized]}  |  Calidad: ${qualityMap[normalized]}`));
+    console.log('');
+  } catch (err) {
+    console.log(RED(`  ✖ Error al ajustar esfuerzo: ${(err as Error).message}\n`));
+  }
+}
+
+/** /model free-list — list free models fetched from bridge (live) */
+export async function handleFreeModelList(client: AgentClient): Promise<void> {
+  try {
+    const result = await (client as AgentClient & { request: <T>(type: string, payload: unknown) => Promise<T> })
+      .request<{ models: Array<{ id: string; label: string; provider: string }> }>('LIST_FREE_MODELS', {});
+
+    if (!result?.models?.length) {
+      // Fallback to static catalog
+      handleModelList();
+      return;
+    }
+
+    console.log(`\n  ${BOLD('✦ Modelos gratuitos disponibles (live):')} \n`);
+    for (const m of result.models) {
+      console.log(`  ${GREEN('[0-COST]')}  ${chalk.white.bold(m.label)}  ${GRAY(m.id)}`);
+    }
+    console.log('');
+  } catch {
+    // Agent not connected or handler not present — fall back to static
+    handleModelList();
+  }
+}
+
+/** Top-level dispatcher for /model <args> */
+export async function handleModelCommand(client: AgentClient, args: string): Promise<void> {
+  const parts = args.trim().split(/\s+/);
+  const sub = parts[0]?.toLowerCase() || '';
+
+  switch (sub) {
+    case '':
+      await handleModelStatus(client);
+      break;
+    case 'list':
+      handleModelList();
+      break;
+    case 'set':
+      await handleModelSet(client, parts.slice(1).join(' '));
+      break;
+    case 'effort':
+      await handleModelEffort(client, parts[1] || '');
+      break;
+    default:
+      console.log(YELLOW(`  Subcomando desconocido: "${sub}". Opciones: list, set, effort\n`));
+  }
+}

package/src/commands/subagents.ts

@@ -0,0 +1,150 @@
+import type { AgentClient } from '../client/agent-client';
+import { CYAN_BOLD, DIM, RED, YELLOW } from '../ui/colors';
+
+interface SubagentProfile {
+  profile_id: string;
+  name: string;
+}
+
+interface SubagentStatus {
+  profile_id?: string;
+  name?: string;
+  status?: string;
+  progress?: number;
+  current_action?: string;
+}
+
+function boundedText(value: unknown, maxLength: number): string {
+  if (typeof value !== 'string') return '';
+  const clean = value.replace(/[\r\n|]/g, ' ').trim();
+  return clean.length > maxLength ? `${clean.slice(0, maxLength - 3)}...` : clean;
+}
+
+function statusLabel(status?: string): string {
+  const normalized = status?.toLowerCase() || 'idle';
+  if (['running', 'active', 'in_progress'].includes(normalized)) return 'RUNNING';
+  if (['failed', 'error'].includes(normalized)) return 'FAILED';
+  if (['completed', 'done'].includes(normalized)) return 'DONE';
+  if (['cancelled', 'canceled'].includes(normalized)) return 'STOPPED';
+  return 'IDLE';
+}
+
+export function renderSubagentPanel(
+  profiles: SubagentProfile[],
+  statuses: SubagentStatus[],
+): string {
+  const statusByProfile = new Map<string, SubagentStatus>();
+  for (const status of statuses) {
+    if (status.profile_id) statusByProfile.set(status.profile_id, status);
+  }
+
+  const rows = profiles.map((profile) => {
+    const status = statusByProfile.get(profile.profile_id);
+    const profileId = boundedText(profile.profile_id, 22);
+    const name = boundedText(profile.name, 18);
+    const state = statusLabel(status?.status);
+    const progress = Number.isFinite(status?.progress) ? ` ${status?.progress}%` : '';
+    const action = boundedText(status?.current_action, 26);
+    return [
+      profileId.padEnd(22),
+      name.padEnd(18),
+      `${state}${progress}`,
+      action,
+    ];
+  });
+
+  const headings = ['PROFILE ID', 'NAME', 'STATE', 'CURRENT ACTION'];
+  const widths = [22, 18, 16, 26];
+  const border = `+${widths.map((width) => '-'.repeat(width + 2)).join('+')}+`;
+  const row = (values: string[]) =>
+    `| ${values.map((value, index) => value.padEnd(widths[index])).join(' | ')} |`;
+  const lines = [
+    border,
+    row(headings),
+    border,
+    ...(rows.length > 0
+      ? rows.map(row)
+      : [row(['No profiles', 'available', '', ''])]),
+    border,
+  ];
+  return lines.join('\n');
+}
+
+function asArray<T>(
+  value: unknown,
+  label: string,
+  isItem: (item: unknown) => item is T,
+): T[] {
+  if (!Array.isArray(value) || !value.every(isItem)) {
+    throw new Error(`Agent returned an invalid ${label} list.`);
+  }
+  return value;
+}
+
+function isSubagentProfile(value: unknown): value is SubagentProfile {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const profile = value as Record<string, unknown>;
+  return typeof profile.profile_id === 'string'
+    && typeof profile.name === 'string';
+}
+
+function isSubagentStatus(value: unknown): value is SubagentStatus {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
+  const status = value as Record<string, unknown>;
+  return (status.profile_id === undefined || typeof status.profile_id === 'string')
+    && (status.status === undefined || typeof status.status === 'string')
+    && (status.progress === undefined || typeof status.progress === 'number')
+    && (status.current_action === undefined || typeof status.current_action === 'string');
+}
+
+export async function handleSubagentsCommand(
+  client: AgentClient,
+  args = '',
+): Promise<void> {
+  const trimmed = args.trim();
+  const chatMatch = trimmed.match(/^chat\s+(\S+)\s+([\s\S]+)$/i);
+  if (chatMatch) {
+    const [, profileId, message] = chatMatch;
+    try {
+      const result = await client.request<unknown>(
+        'CHAT_SUBAGENT',
+        { profile_id: profileId, message: message.trim() },
+        120000,
+      );
+      console.log('\n' + CYAN_BOLD(`  SUBAGENT ${profileId}`));
+      if (
+        result !== null
+        && typeof result === 'object'
+        && 'response' in result
+        && typeof result.response === 'string'
+      ) {
+        console.log(result.response);
+      } else {
+        console.log(JSON.stringify(result, null, 2));
+      }
+      console.log('');
+    } catch (error) {
+      console.log(RED(`  No se pudo contactar al subagente: ${(error as Error).message}\n`));
+    }
+    return;
+  }
+
+  if (trimmed && !/^list$/i.test(trimmed)) {
+    console.log(YELLOW('  Uso: /subagents [list] | /subagents chat <id> <mensaje>\n'));
+    return;
+  }
+
+  try {
+    const [profilesValue, statusesValue] = await Promise.all([
+      client.request<unknown[]>('GET_SUBAGENT_PROFILES'),
+      client.request<unknown[]>('GET_SUBAGENT_STATUS'),
+    ]);
+    const profiles = asArray(profilesValue, 'subagent profile', isSubagentProfile);
+    const statuses = asArray(statusesValue, 'subagent status', isSubagentStatus);
+    console.log(`\n${CYAN_BOLD('  HELIX SUBAGENTS')}`);
+    console.log(renderSubagentPanel(profiles, statuses));
+    console.log(DIM('  Chat: /subagents chat <profile_id> <mensaje>\n'));
+  } catch (error) {
+    console.log(RED(`  No se pudo cargar el panel de subagentes: ${(error as Error).message}\n`));
+  }
+}

package/src/config/mcp-defaults.ts

@@ -9,10 +9,19 @@ export interface McpDefaultDefinition {
 
 /** Catalog only: entries are never enabled or installed automatically. */
 export const MCP_DEFAULTS: McpDefaultDefinition[] = [
-  { id: 'filesystem', label: 'Archivos locales', purpose: 'Carpeta elegida por el usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo rutas autorizadas' },
+  { id: 'filesystem', label: 'Archivos locales', purpose: 'Carpetas y archivos del equipo del usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo rutas autorizadas' },
   { id: 'obsidian', label: 'Obsidian / Helix Vault', purpose: 'Leer y gestionar una bóveda concreta', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo la bóveda seleccionada' },
   { id: 'vscode', label: 'VS Code', purpose: 'Trabajar con el workspace seleccionado', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo el workspace seleccionado' },
-  { id: 'github', label: 'GitHub', purpose: 'Repositorios, issues y pull requests', transport: 'stdio', activation: 'oauth-opt-in', privacy: 'Requiere token u OAuth del usuario' },
-  { id: 'gmail', label: 'Gmail', purpose: 'Correo y búsqueda de mensajes', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere OAuth explícito del usuario' },
-  { id: 'notion', label: 'Notion', purpose: 'Páginas y bases de datos', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere integración autorizada' },
+  { id: 'cursor', label: 'Cursor', purpose: 'Proyectos y editor de código del usuario', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo el workspace autorizado' },
+  { id: 'github', label: 'GitHub', purpose: 'Repositorios, issues, pull requests y código', transport: 'stdio', activation: 'oauth-opt-in', privacy: 'Requiere token u OAuth del usuario' },
+  { id: 'linear', label: 'Linear', purpose: 'Issues, roadmap y trabajo del equipo', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere acceso autorizado del workspace' },
+  { id: 'gmail', label: 'Gmail', purpose: 'Correo, búsquedas y mensajes relevantes', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere OAuth explícito del usuario' },
+  { id: 'google-drive', label: 'Google Drive', purpose: 'Documentos y archivos compartidos', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere acceso autorizado a la cuenta' },
+  { id: 'notion', label: 'Notion', purpose: 'Páginas, bases de datos y conocimiento', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere integración autorizada' },
+  { id: 'chatgpt', label: 'ChatGPT', purpose: 'Acceso a tareas y contexto de chat del usuario', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere conexión autorizada del usuario' },
+  { id: 'claude-desktop', label: 'Claude Desktop', purpose: 'Contexto y trabajo en la app desktop de Claude', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo los recursos autorizados por el usuario' },
+  { id: 'word', label: 'Microsoft Word', purpose: 'Documentos y edición de texto', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+  { id: 'excel', label: 'Microsoft Excel', purpose: 'Hojas de cálculo, análisis y tabulación', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+  { id: 'powerpoint', label: 'Microsoft PowerPoint', purpose: 'Presentaciones y material visual', transport: 'stdio', activation: 'local-opt-in', privacy: 'Solo archivos autorizados' },
+  { id: 'antigravity', label: 'Antigravity', purpose: 'Workspace y flujos de automatización del usuario', transport: 'connector', activation: 'oauth-opt-in', privacy: 'Requiere conexión explícita del usuario' },
 ];

package/src/global.d.ts

@@ -0,0 +1,23 @@
+// Declaration shims for modules without bundled @types in this workspace.
+// These are minimal stubs to satisfy TypeScript when explicit "types" is set.
+
+declare module 'prompts' {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function prompts(questions: any | any[]): Promise<Record<string, any>>;
+  export = prompts;
+}
+
+declare module 'jpeg-js' {
+  interface RawImageData {
+    width: number;
+    height: number;
+    data: Buffer | Uint8Array;
+  }
+  interface DecodeResult extends RawImageData {
+    comments?: string[];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function decode(jpegData: Buffer | Uint8Array, opts?: Record<string, any>): DecodeResult;
+  function encode(rawImageData: RawImageData, quality?: number): { data: Buffer; width: number; height: number };
+  export { decode, encode };
+}

package/src/index.ts

@@ -32,6 +32,7 @@ import type { HelixSettings } from './client/types';
 import { handleShowApiKey } from './commands/apikey';
 import { ORANGE, CYAN, GREEN, RED, BOLD, DIM } from './ui/colors';
 import { getAsciiLogo } from './ui/banner';
+import packageJson from '../package.json';
 
 async function readStdin(): Promise<string> {
   if (process.stdin.isTTY) {
@@ -73,7 +74,7 @@ const program = new Command();
 program
   .name('helix')
   .description('HELIX - Interactive Terminal CLI for Windows AI Desktop Agent')
-  .version('0.2.14')
+  .version(packageJson.version)
   .option('-u, --ws-url <url>', 'URL del servidor WebSocket del agente', getWsUrl())
   .option('-t, --token <token>', 'Token de autenticación WebSocket de HELIX', getWsToken())
   .option('--plain', 'Desactivar formato enriquecido de Markdown y mostrar texto plano sin asteriscos')