@celilo/cli 0.1.0

package/src/cli/completion.test.ts

@@ -0,0 +1,37 @@
+/**
+ * Tests for shell completion
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { getCompletions } from './completion';
+
+describe('getCompletions', () => {
+  it('completes top-level commands', async () => {
+    const suggestions = await getCompletions(['m'], 0);
+    expect(suggestions).toContain('module');
+    expect(suggestions).toContain('machine');
+    expect(suggestions).not.toContain('service');
+  });
+
+  it('completes service subcommands', async () => {
+    const suggestions = await getCompletions(['service', 'v'], 1);
+    expect(suggestions).toContain('verify');
+    expect(suggestions).not.toContain('add');
+  });
+
+  it('completes service add providers', async () => {
+    const suggestions = await getCompletions(['service', 'add', 'p'], 2);
+    expect(suggestions).toContain('proxmox');
+    expect(suggestions).not.toContain('digitalocean');
+  });
+
+  it('returns empty array for unknown context', async () => {
+    const suggestions = await getCompletions(['unknown', 'command'], 2);
+    expect(suggestions).toEqual([]);
+  });
+
+  it('handles completion at different positions', async () => {
+    const suggestions = await getCompletions(['module', 'li'], 1);
+    expect(suggestions).toContain('list');
+  });
+});

package/src/cli/completion.ts

@@ -0,0 +1,482 @@
+/**
+ * Shell Completion Support
+ * Provides tab completion suggestions for bash/zsh
+ */
+
+import { eq } from 'drizzle-orm';
+import { getDb } from '../db/client';
+import { capabilities, modules } from '../db/schema';
+import type { ModuleManifest } from '../manifest/schema';
+import { listBackups } from '../services/backup-metadata';
+import { listBackupStorages } from '../services/backup-storage';
+import { listContainerServices } from '../services/container-service';
+import { listMachines } from '../services/machine-pool';
+
+/**
+ * Get completion suggestions based on current command context
+ *
+ * @param words - Array of words typed so far
+ * @param current - Index of word being completed
+ * @returns Array of completion suggestions
+ */
+export async function getCompletions(words: string[], current: number): Promise<string[]> {
+  // Remove 'celilo' from words if present
+  const args = words[0] === 'celilo' ? words.slice(1) : words;
+  const currentIndex = words[0] === 'celilo' ? current - 1 : current;
+
+  // Complete top-level commands
+  // currentIndex === 0 means we're completing the first word (the command)
+  if (currentIndex === 0) {
+    const commands = [
+      'backup',
+      'capability',
+      'help',
+      'hook',
+      'package',
+      'module',
+      'service',
+      'storage',
+      'machine',
+      'system',
+      'ipam',
+      'completion',
+      'status',
+      'version',
+    ];
+    return filterSuggestions(commands, args[0] || '');
+  }
+
+  const command = args[0];
+
+  // Capability subcommands
+  if (command === 'capability' && currentIndex === 1) {
+    const subcommands = ['list', 'info'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // Capability info - complete with capability names
+  if (command === 'capability' && args[1] === 'info' && currentIndex === 2) {
+    const db = getDb();
+    const capabilityRows = db
+      .select({ name: capabilities.capabilityName })
+      .from(capabilities)
+      .all();
+    const capabilityNames = capabilityRows.map((c) => c.name);
+    return filterSuggestions(capabilityNames, args[2] || '');
+  }
+
+  // Hook subcommands
+  if (command === 'hook' && currentIndex === 1) {
+    const subcommands = ['run'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // Hook run - complete with module IDs
+  if (command === 'hook' && args[1] === 'run' && currentIndex === 2) {
+    const db = getDb();
+    const moduleRows = db.select({ id: modules.id }).from(modules).all();
+    const moduleIds = moduleRows.map((p) => p.id);
+    return filterSuggestions(moduleIds, args[2] || '');
+  }
+
+  // Hook run <module-id> - complete with hook names from manifest
+  if (command === 'hook' && args[1] === 'run' && currentIndex === 3) {
+    const db = getDb();
+    const module = db
+      .select()
+      .from(modules)
+      .where(eq(modules.id, args[2] || ''))
+      .get();
+    if (module?.manifestData) {
+      const manifest = module.manifestData as ModuleManifest;
+      const hookNames = Object.keys(manifest.hooks || {});
+      return filterSuggestions(hookNames, args[3] || '');
+    }
+  }
+
+  // Module subcommands
+  if (command === 'module' && currentIndex === 1) {
+    const subcommands = [
+      'import',
+      'list',
+      'remove',
+      'update',
+      'audit',
+      'config',
+      'show-config',
+      'show-zone',
+      'build',
+      'generate',
+      'deploy',
+      'destroy',
+      'health',
+      'logs',
+      'run-hook',
+      'secret',
+      'status',
+      'types',
+      'validate',
+    ];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // Module config subcommands (celilo module config set/get)
+  if (command === 'module' && args[1] === 'config' && currentIndex === 2) {
+    const subcommands = ['set', 'get'];
+    return filterSuggestions(subcommands, args[2] || '');
+  }
+
+  // Module types subcommands (celilo module types generate/check)
+  if (command === 'module' && args[1] === 'types' && currentIndex === 2) {
+    const subcommands = ['generate', 'check'];
+    return filterSuggestions(subcommands, args[2] || '');
+  }
+
+  // Module config set/get - complete with module IDs
+  if (
+    command === 'module' &&
+    args[1] === 'config' &&
+    (args[2] === 'set' || args[2] === 'get') &&
+    currentIndex === 3
+  ) {
+    const db = getDb();
+    const modulesList = db.select({ id: modules.id }).from(modules).all();
+    const moduleIds = modulesList.map((p) => p.id);
+    return filterSuggestions(moduleIds, args[3] || '');
+  }
+
+  // Module config set/get <module-id> - complete with config variable names
+  if (
+    command === 'module' &&
+    args[1] === 'config' &&
+    (args[2] === 'set' || args[2] === 'get') &&
+    currentIndex === 4
+  ) {
+    const db = getDb();
+    const module = db
+      .select()
+      .from(modules)
+      .where(eq(modules.id, args[3] || ''))
+      .get();
+    if (module?.manifestData) {
+      const manifest = module.manifestData as ModuleManifest;
+      const varNames = (manifest.variables?.owns || [])
+        .filter((v) => v.source === 'user' || !v.source)
+        .map((v) => v.name);
+      return filterSuggestions(varNames, args[4] || '');
+    }
+  }
+
+  // Module secret subcommands (celilo module secret set/list)
+  if (command === 'module' && args[1] === 'secret' && currentIndex === 2) {
+    const subcommands = ['set', 'list'];
+    return filterSuggestions(subcommands, args[2] || '');
+  }
+
+  // Module secret set/list - complete with module IDs
+  if (
+    command === 'module' &&
+    args[1] === 'secret' &&
+    (args[2] === 'set' || args[2] === 'list') &&
+    currentIndex === 3
+  ) {
+    const db = getDb();
+    const modulesList = db.select({ id: modules.id }).from(modules).all();
+    const moduleIds = modulesList.map((p) => p.id);
+    return filterSuggestions(moduleIds, args[3] || '');
+  }
+
+  // Module secret set <module-id> - complete with secret names
+  if (command === 'module' && args[1] === 'secret' && args[2] === 'set' && currentIndex === 4) {
+    const db = getDb();
+    const module = db
+      .select()
+      .from(modules)
+      .where(eq(modules.id, args[3] || ''))
+      .get();
+    if (module?.manifestData) {
+      const manifest = module.manifestData as ModuleManifest;
+      const secretNames = (manifest.secrets?.declares || []).map((s) => s.name);
+      return filterSuggestions(secretNames, args[4] || '');
+    }
+  }
+
+  // Service subcommands
+  if (command === 'service' && currentIndex === 1) {
+    const subcommands = ['add', 'list', 'verify', 'reconfigure', 'remove', 'config'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // Service add providers
+  if (command === 'service' && args[1] === 'add' && currentIndex === 2) {
+    const providers = ['proxmox', 'digitalocean'];
+    return filterSuggestions(providers, args[2] || '');
+  }
+
+  // Service verify - complete with service IDs
+  if (command === 'service' && args[1] === 'verify' && currentIndex === 2) {
+    const services = await listContainerServices();
+    const serviceIds = services.map((s) => s.serviceId);
+    return filterSuggestions(serviceIds, args[2] || '');
+  }
+
+  // Service reconfigure - complete with service IDs
+  if (command === 'service' && args[1] === 'reconfigure' && currentIndex === 2) {
+    const services = await listContainerServices();
+    const serviceIds = services.map((s) => s.serviceId);
+    return filterSuggestions(serviceIds, args[2] || '');
+  }
+
+  // Service remove - complete with service IDs
+  if (command === 'service' && args[1] === 'remove' && currentIndex === 2) {
+    const services = await listContainerServices();
+    const serviceIds = services.map((s) => s.serviceId);
+    return filterSuggestions(serviceIds, args[2] || '');
+  }
+
+  // Service config operations
+  if (command === 'service' && args[1] === 'config' && currentIndex === 2) {
+    const operations = ['get', 'set'];
+    return filterSuggestions(operations, args[2] || '');
+  }
+
+  // Service config get - complete with service IDs
+  if (command === 'service' && args[1] === 'config' && args[2] === 'get' && currentIndex === 3) {
+    const services = await listContainerServices();
+    const serviceIds = services.map((s) => s.serviceId);
+    return filterSuggestions(serviceIds, args[3] || '');
+  }
+
+  // Service config get - complete with config keys
+  if (command === 'service' && args[1] === 'config' && args[2] === 'get' && currentIndex === 4) {
+    const configKeys = ['name', 'zones', 'providerConfig'];
+    return filterSuggestions(configKeys, args[4] || '');
+  }
+
+  // Service config set - complete with service IDs
+  if (command === 'service' && args[1] === 'config' && args[2] === 'set' && currentIndex === 3) {
+    const services = await listContainerServices();
+    const serviceIds = services.map((s) => s.serviceId);
+    return filterSuggestions(serviceIds, args[3] || '');
+  }
+
+  // Service config set - complete with config keys
+  if (command === 'service' && args[1] === 'config' && args[2] === 'set' && currentIndex === 4) {
+    const configKeys = ['name', 'zones', 'providerConfig'];
+    return filterSuggestions(configKeys, args[4] || '');
+  }
+
+  // Machine subcommands
+  if (command === 'machine' && currentIndex === 1) {
+    const subcommands = ['add', 'list', 'status', 'remove', 'earmark', 'detect'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // Machine remove/earmark - complete with machine hostnames and IPs
+  if (
+    command === 'machine' &&
+    (args[1] === 'remove' || args[1] === 'earmark') &&
+    currentIndex === 2
+  ) {
+    const machineList = await listMachines();
+    const identifiers = [
+      ...machineList.map((m) => m.hostname),
+      ...machineList.map((m) => m.ipAddress),
+      ...machineList.flatMap((m) => m.interfaces.map((i) => i.ipAddress)),
+    ];
+    return filterSuggestions(identifiers, args[2] || '');
+  }
+
+  // Machine earmark - complete with module IDs at position 3
+  if (command === 'machine' && args[1] === 'earmark' && currentIndex === 3) {
+    const db = getDb();
+    const moduleRows = db.select().from(modules).all();
+    const moduleIds = moduleRows.map((p: { id: string }) => p.id);
+    return filterSuggestions(moduleIds, args[3] || '');
+  }
+
+  // Module commands that take module ID directly at position 2
+  if (command === 'module' && currentIndex === 2) {
+    const moduleCommands = [
+      'generate',
+      'deploy',
+      'destroy',
+      'logs',
+      'remove',
+      'build',
+      'run-hook',
+      'status',
+    ];
+    if (moduleCommands.includes(args[1] || '')) {
+      const db = getDb();
+      const moduleRows = db.select().from(modules).all();
+      const moduleIds = moduleRows.map((p: { id: string }) => p.id);
+      return filterSuggestions(moduleIds, args[2] || '');
+    }
+  }
+
+  // Module run-hook <module-id> - complete with hook names from manifest
+  if (command === 'module' && args[1] === 'run-hook' && currentIndex === 3) {
+    const db = getDb();
+    const module = db
+      .select()
+      .from(modules)
+      .where(eq(modules.id, args[2] || ''))
+      .get();
+    if (module?.manifestData) {
+      const manifest = module.manifestData as ModuleManifest;
+      const hookNames = Object.keys(manifest.hooks || {});
+      return filterSuggestions(hookNames, args[3] || '');
+    }
+  }
+
+  // Storage subcommands
+  if (command === 'storage' && currentIndex === 1) {
+    const subcommands = ['add', 'list', 'remove', 'verify', 'set-default'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // Storage add providers
+  if (command === 'storage' && args[1] === 'add' && currentIndex === 2) {
+    const providers = ['local', 's3'];
+    return filterSuggestions(providers, args[2] || '');
+  }
+
+  // Storage remove/verify/set-default - complete with storage IDs
+  if (
+    command === 'storage' &&
+    (args[1] === 'remove' || args[1] === 'verify' || args[1] === 'set-default') &&
+    currentIndex === 2
+  ) {
+    const storages = listBackupStorages();
+    const storageIds = storages.map((s) => s.storageId);
+    return filterSuggestions(storageIds, args[2] || '');
+  }
+
+  // Backup subcommands
+  if (command === 'backup' && currentIndex === 1) {
+    const subcommands = ['create', 'list', 'restore', 'delete', 'prune', 'name', 'import'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // Backup create/list/prune - complete with module IDs
+  if (
+    command === 'backup' &&
+    (args[1] === 'create' || args[1] === 'list' || args[1] === 'prune') &&
+    currentIndex === 2
+  ) {
+    const db = getDb();
+    const moduleRows = db.select({ id: modules.id }).from(modules).all();
+    const moduleIds = moduleRows.map((p: { id: string }) => p.id);
+    return filterSuggestions(moduleIds, args[2] || '');
+  }
+
+  // Backup restore/delete/name - complete with short backup IDs and names
+  if (
+    command === 'backup' &&
+    (args[1] === 'restore' || args[1] === 'delete' || args[1] === 'name') &&
+    currentIndex === 2
+  ) {
+    const backupList = listBackups({ limit: 50 });
+    const suggestions = backupList.map((b) => b.id.substring(0, 8));
+    for (const b of backupList) {
+      if (b.name) suggestions.push(b.name);
+    }
+    return filterSuggestions(suggestions, args[2] || '');
+  }
+
+  // IPAM subcommands
+  if (command === 'ipam' && currentIndex === 1) {
+    const subcommands = ['show', 'list-allocations', 'vmid', 'ip'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // Completion subcommands
+  if (command === 'completion' && currentIndex === 1) {
+    const subcommands = ['bash', 'zsh'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // System subcommands
+  if (command === 'system' && currentIndex === 1) {
+    const subcommands = ['init', 'config', 'secret', 'vault-password'];
+    return filterSuggestions(subcommands, args[1] || '');
+  }
+
+  // System config operations
+  if (command === 'system' && args[1] === 'config' && currentIndex === 2) {
+    const operations = ['get', 'set'];
+    return filterSuggestions(operations, args[2] || '');
+  }
+
+  // System secret operations
+  if (command === 'system' && args[1] === 'secret' && currentIndex === 2) {
+    const operations = ['get', 'set'];
+    return filterSuggestions(operations, args[2] || '');
+  }
+
+  return [];
+}
+
+/**
+ * Filter suggestions based on current input
+ */
+function filterSuggestions(options: string[], current: string): string[] {
+  if (!current) return options;
+  return options.filter((opt) => opt.startsWith(current));
+}
+
+/**
+ * Generate bash completion script
+ */
+export function generateBashCompletion(): string {
+  return `# Celilo bash completion
+_celilo_completion() {
+    local cur prev words cword
+    _init_completion || return
+
+    # Get completions from celilo
+    local completions=$(celilo --get-completions "\${COMP_WORDS[@]}" "\${COMP_CWORD}")
+
+    # Apply completions
+    COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
+    return 0
+}
+
+complete -F _celilo_completion celilo
+`;
+}
+
+/**
+ * Generate zsh completion script
+ */
+export function generateZshCompletion(): string {
+  return `#compdef celilo
+
+_celilo() {
+    local -a completions
+    local -a words_array
+    local current_word
+
+    # Get current word index (CURRENT is 1-based)
+    current_word=\${CURRENT}
+
+    # Get words from command line
+    words_array=("\${words[@]}")
+
+    # Call celilo to get completions (returns newline-separated list)
+    local result
+    result=$(celilo --get-completions "\${words_array[@]}" "$current_word" 2>/dev/null)
+
+    # Split result into array by newlines
+    completions=("\${(@f)result}")
+
+    # Provide completions
+    if (( \${#completions} > 0 )); then
+        compadd -a completions
+    fi
+}
+
+compdef _celilo celilo
+`;
+}