@celilo/cli 0.1.0

package/src/cli/commands/module-build.ts

@@ -0,0 +1,60 @@
+/**
+ * Module build command
+ *
+ * Executes module build scripts (Ansible playbooks) for imported modules
+ */
+
+import { getDb } from '../../db/client';
+import { buildModuleFromSource } from '../../services/module-build';
+import { getArg, validateRequiredArgs } from '../parser';
+import type { CommandResult } from '../types';
+
+/**
+ * Handle module build command
+ *
+ * Usage:
+ *   celilo module build <module-id>
+ *
+ * @param args - Command arguments
+ * @param flags - Command flags (unused)
+ * @returns Command result
+ */
+export async function handleModuleBuild(
+  args: string[],
+  _flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  // Validate arguments
+  const error = validateRequiredArgs(args, 1);
+  if (error) {
+    return {
+      success: false,
+      error: `${error}\n\nUsage:\n  celilo module build <module-id>`,
+    };
+  }
+
+  const moduleId = getArg(args, 0);
+  if (!moduleId) {
+    return {
+      success: false,
+      error: 'Module ID is required',
+    };
+  }
+
+  const db = getDb();
+  const result = await buildModuleFromSource(moduleId, db);
+
+  if (!result.success) {
+    return {
+      success: false,
+      error: result.error || 'Build failed',
+    };
+  }
+
+  return {
+    success: true,
+    message: `✓ Build successful\nArtifacts: ${result.artifacts?.join(', ') || 'none'}`,
+    data: {
+      artifacts: result.artifacts,
+    },
+  };
+}

package/src/cli/commands/module-config.ts

@@ -0,0 +1,170 @@
+/**
+ * Module config command
+ */
+
+import { eq } from 'drizzle-orm';
+import { getDb } from '../../db/client';
+import { modules } from '../../db/schema';
+import {
+  formatConfigValue,
+  getAllModuleConfigValues,
+  getModuleConfigValue,
+  setModuleConfigValue,
+} from '../../services/module-config';
+import { getArg, validateRequiredArgs } from '../parser';
+import type { CommandResult } from '../types';
+
+/**
+ * Handle module config set command
+ *
+ * Usage: celilo module config set <module-id> <key> <value>
+ *
+ * @param args - Command arguments
+ * @returns Command result
+ */
+export async function handleModuleConfigSet(args: string[]): Promise<CommandResult> {
+  // Validate arguments
+  const error = validateRequiredArgs(args, 3);
+  if (error) {
+    return {
+      success: false,
+      error: `${error}\n\nUsage: celilo module config set <module-id> <key> <value>`,
+    };
+  }
+
+  const moduleId = getArg(args, 0);
+  const key = getArg(args, 1);
+  const value = getArg(args, 2);
+
+  if (!moduleId || !key || !value) {
+    return {
+      success: false,
+      error: 'Module ID, key, and value are required',
+    };
+  }
+
+  const db = getDb();
+
+  // Check if module exists
+  const module = db.select().from(modules).where(eq(modules.id, moduleId)).get();
+  if (!module) {
+    return {
+      success: false,
+      error: `Module not found: ${moduleId}`,
+    };
+  }
+
+  // Validate key against manifest
+  const manifest = module.manifestData as Record<string, unknown>;
+  const variables = manifest.variables as
+    | { owns?: Array<{ name: string; required?: boolean; default?: string }> }
+    | undefined;
+  const declaredVars = variables?.owns || [];
+
+  // Check if key is declared in manifest
+  const declaredVar = declaredVars.find((v) => v.name === key);
+  if (!declaredVar) {
+    const validKeys = declaredVars.map((v) => v.name).join(', ');
+    return {
+      success: false,
+      error: `Invalid config key '${key}' for module ${moduleId}.\n\nValid keys: ${validKeys || '(none declared)'}`,
+    };
+  }
+
+  // Set config value using service (handles primitive and complex types)
+  try {
+    await setModuleConfigValue(moduleId, key, value);
+
+    return {
+      success: true,
+      message: `Set config for ${moduleId}: ${key}`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Failed to set config: ${error instanceof Error ? error.message : String(error)}`,
+    };
+  }
+}
+
+/**
+ * Handle module config get command
+ *
+ * Usage: celilo module config get <module-id> [key]
+ *
+ * @param args - Command arguments
+ * @returns Command result
+ */
+export async function handleModuleConfigGet(args: string[]): Promise<CommandResult> {
+  // Validate arguments
+  const error = validateRequiredArgs(args, 1);
+  if (error) {
+    return {
+      success: false,
+      error: `${error}\n\nUsage: celilo module config get <module-id> [key]`,
+    };
+  }
+
+  const moduleId = getArg(args, 0);
+  const key = getArg(args, 1);
+
+  if (!moduleId) {
+    return {
+      success: false,
+      error: 'Module ID is required',
+    };
+  }
+
+  const db = getDb();
+
+  // Check if module exists
+  const module = db.select().from(modules).where(eq(modules.id, moduleId)).get();
+  if (!module) {
+    return {
+      success: false,
+      error: `Module not found: ${moduleId}`,
+    };
+  }
+
+  if (key) {
+    // Get specific config value
+    const configValue = getModuleConfigValue(moduleId, key);
+
+    if (!configValue) {
+      return {
+        success: false,
+        error: `Config key not found: ${key}`,
+      };
+    }
+
+    const formatted = formatConfigValue(configValue);
+
+    return {
+      success: true,
+      message: `${key} = ${formatted}`,
+      data: { key, value: configValue.value },
+    };
+  }
+
+  // Get all config for module
+  const configs = getAllModuleConfigValues(moduleId);
+
+  if (configs.length === 0) {
+    return {
+      success: true,
+      message: `No configuration set for ${moduleId}`,
+    };
+  }
+
+  const lines = [`Configuration for ${moduleId}:`, ''];
+  for (const config of configs) {
+    const formatted = formatConfigValue(config);
+    lines.push(`${config.key} = ${formatted}`);
+  }
+
+  return {
+    success: true,
+    message: lines.join('\n'),
+    data: configs.map((c) => ({ key: c.key, value: c.value })),
+  };
+}

package/src/cli/commands/module-deploy.ts

@@ -0,0 +1,71 @@
+/**
+ * Module deploy command
+ *
+ * Deploys module to infrastructure (Terraform + Ansible)
+ */
+
+import { getDb } from '../../db/client';
+import { formatPreflightResult, runPreflight } from '../../services/deploy-preflight';
+import { deployModule } from '../../services/module-deploy';
+import { getArg, hasFlag, validateRequiredArgs } from '../parser';
+import type { CommandResult } from '../types';
+
+/**
+ * Handle module deploy command
+ *
+ * Usage:
+ *   celilo module deploy <module-id> [--no-interactive] [--debug] [--preflight]
+ *
+ * @param args - Command arguments
+ * @param flags - Command flags
+ * @returns Command result
+ */
+export async function handleModuleDeploy(
+  args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  // Validate arguments
+  const error = validateRequiredArgs(args, 1);
+  if (error) {
+    return {
+      success: false,
+      error: `${error}\n\nUsage:\n  celilo module deploy <module-id> [--no-interactive] [--preflight]`,
+    };
+  }
+
+  const moduleId = getArg(args, 0);
+  if (!moduleId) {
+    return {
+      success: false,
+      error: 'Module ID is required',
+    };
+  }
+
+  const db = getDb();
+
+  // --preflight: fast validation only, no actual deployment
+  if (hasFlag(flags, 'preflight')) {
+    const preflight = await runPreflight(moduleId, db);
+    const message = formatPreflightResult(preflight);
+    return preflight.success ? { success: true, message } : { success: false, error: message };
+  }
+
+  const noInteractive = hasFlag(flags, 'no-interactive');
+  const debug = hasFlag(flags, 'debug');
+
+  const result = await deployModule(moduleId, db, { noInteractive, debug });
+
+  if (!result.success) {
+    return {
+      success: false,
+      error: result.error || 'Deployment failed',
+      details: result.phases,
+    };
+  }
+
+  return {
+    success: true,
+    message: `✓ Module '${moduleId}' deployed successfully`,
+    data: result.phases,
+  };
+}

package/src/cli/commands/module-generate.ts

@@ -0,0 +1,236 @@
+/**
+ * Module generate command
+ */
+
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { eq } from 'drizzle-orm';
+import {
+  promptForMissingCapabilitySecrets,
+  validateCapabilitySecrets,
+} from '../../capabilities/secret-validation';
+import { getDb } from '../../db/client';
+import { moduleConfigs, modules } from '../../db/schema';
+import type { ModuleManifest } from '../../manifest/schema';
+import { interviewForMissingSecrets, validateModuleSecrets } from '../../services/config-interview';
+import { getModuleBuildStatus, verifyArtifactsExist } from '../../services/module-build';
+import { generateTemplates } from '../../templates/generator';
+import { promptForMissingConfig } from '../interactive-config';
+import { getArg, getFlag, validateRequiredArgs } from '../parser';
+import type { CommandResult } from '../types';
+
+/**
+ * Handle module generate command
+ *
+ * Usage: celilo module generate <module-id> [--output <path>]
+ *
+ * @param args - Command arguments
+ * @param flags - Command flags
+ * @returns Command result
+ */
+export async function handleModuleGenerate(
+  args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  // Validate arguments
+  const error = validateRequiredArgs(args, 1);
+  if (error) {
+    return {
+      success: false,
+      error: `${error}\n\nUsage: celilo module generate <module-id> [--output <path>]`,
+    };
+  }
+
+  const moduleId = getArg(args, 0);
+  if (!moduleId) {
+    return {
+      success: false,
+      error: 'Module ID is required',
+    };
+  }
+
+  const db = getDb();
+
+  // Check if module exists
+  const module = db.select().from(modules).where(eq(modules.id, moduleId)).get();
+  if (!module) {
+    return {
+      success: false,
+      error: `Module not found: ${moduleId}`,
+    };
+  }
+
+  // Get module path and output path
+  const modulePath = module.sourcePath;
+
+  // Check if module files exist (may have been deleted from /tmp)
+  if (!existsSync(modulePath)) {
+    return {
+      success: false,
+      error: `Module files not found at: ${modulePath}\n\nThe module files may have been deleted (e.g., /tmp cleanup).\n\nTo fix this:\n  1. Remove the module: celilo module remove ${moduleId}\n  2. Re-import it: celilo module import <original-module-path>\n  3. Reconfigure if needed: celilo module config set ${moduleId} <key> <value>\n  4. Regenerate: celilo module generate ${moduleId}`,
+    };
+  }
+
+  // Check if module requires build step
+  const manifest = module.manifestData as ModuleManifest;
+  if (manifest.build) {
+    const buildStatus = await getModuleBuildStatus(moduleId, db);
+
+    if (!buildStatus || buildStatus.status !== 'success') {
+      return {
+        success: false,
+        error:
+          `Module ${moduleId} requires build step before generation.\n\n` +
+          `Run: celilo module build ${moduleId}`,
+      };
+    }
+
+    // Verify artifacts still exist
+    if (buildStatus.artifacts.length > 0) {
+      const artifactsValid = verifyArtifactsExist(buildStatus.artifacts);
+
+      if (!artifactsValid) {
+        return {
+          success: false,
+          error: `Build artifacts missing or invalid.\n\nRebuild: celilo module build ${moduleId}`,
+        };
+      }
+    }
+  }
+
+  const outputPathFlag = getFlag(flags, 'output', '');
+  const outputPath = outputPathFlag || `${modulePath}/generated`;
+  const resolvedOutputPath = resolve(outputPath);
+
+  // Check for missing capability secrets
+  const secretValidation = await validateCapabilitySecrets(moduleId, db.$client);
+
+  if (!secretValidation.success) {
+    // If missing secrets and in interactive mode, prompt user
+    if (process.stdin.isTTY && secretValidation.missingSecrets) {
+      const promptResult = await promptForMissingCapabilitySecrets(
+        moduleId,
+        secretValidation.missingSecrets,
+        db.$client,
+      );
+
+      if (!promptResult.success) {
+        return {
+          success: false,
+          error: promptResult.error || 'Failed to collect capability secrets',
+        };
+      }
+    } else {
+      // Non-interactive: error with helpful message
+      return {
+        success: false,
+        error: secretValidation.error || 'Missing capability secrets',
+      };
+    }
+  }
+
+  // Check for missing module secrets
+  const moduleSecretsMissing = await validateModuleSecrets(moduleId, db);
+
+  if (moduleSecretsMissing.length > 0) {
+    // Always try to interview for missing secrets
+    // Auto-generated secrets work in non-interactive mode
+    const result = await interviewForMissingSecrets(moduleId, moduleSecretsMissing, db);
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error || 'Failed to collect module secrets',
+      };
+    }
+  }
+
+  // Try to generate templates
+  let result = await generateTemplates({
+    moduleId,
+    modulePath,
+    outputPath: resolvedOutputPath,
+    db,
+  });
+
+  // If missing config, prompt for it and retry
+  if (!result.success && result.error?.includes('Missing required configuration')) {
+    // Get missing required variables
+    const requiredVars = manifest.variables?.owns?.filter((v) => v.required) || [];
+
+    if (requiredVars.length > 0) {
+      // Get current module configuration
+      const configs = db
+        .select()
+        .from(moduleConfigs)
+        .where(eq(moduleConfigs.moduleId, moduleId))
+        .all();
+
+      const configMap = new Map(configs.map((c) => [c.key, c.value || c.valueJson]));
+
+      // Find missing variables
+      const missingVars = requiredVars.filter((v) => !configMap.has(v.name));
+
+      if (missingVars.length > 0) {
+        // Only prompt if in interactive mode
+        if (!process.stdin.isTTY) {
+          // Non-interactive: return error
+          return {
+            success: false,
+            error: result.error || 'Missing required configuration',
+          };
+        }
+
+        // Prompt for missing config
+        const collected = await promptForMissingConfig(moduleId, missingVars, db);
+
+        if (!collected) {
+          return {
+            success: false,
+            error: 'Failed to collect required configuration',
+          };
+        }
+
+        // Retry generation with new config
+        result = await generateTemplates({
+          moduleId,
+          modulePath,
+          outputPath: resolvedOutputPath,
+          db,
+        });
+      }
+    }
+  }
+
+  if (!result.success) {
+    return {
+      success: false,
+      error: result.error,
+      details: result.details,
+    };
+  }
+
+  // Build infrastructure info message
+  let infrastructureMsg = '';
+  if (result.infrastructure) {
+    const infra = result.infrastructure;
+
+    if (infra.type === 'machine') {
+      infrastructureMsg = `\n📦 Infrastructure: Existing machine "${infra.machineName || infra.machineId}" (zone: ${infra.zone})`;
+    } else if (infra.type === 'container_service') {
+      infrastructureMsg = `\n📦 Infrastructure: Container service "${infra.serviceName || infra.serviceId}" (zone: ${infra.zone})`;
+    }
+  }
+
+  const filesList = result.files.map((f) => `  - ${f.path}`).join('\n');
+
+  return {
+    success: true,
+    message: `Successfully generated ${result.files.length} files:\n${filesList}\n\nOutput: ${result.outputPath}${infrastructureMsg}`,
+    data: {
+      fileCount: result.files.length,
+      outputPath: result.outputPath,
+      files: result.files,
+      infrastructure: result.infrastructure,
+    },
+  };
+}

package/src/cli/commands/module-health.ts

@@ -0,0 +1,108 @@
+/**
+ * Module health check command
+ *
+ * Usage:
+ *   celilo module health [module-id] [--json] [--debug]
+ */
+
+import { getDb } from '../../db/client';
+import type { HealthCheckResult } from '../../services/health-runner';
+import { runAllHealthChecks, runModuleHealthCheck } from '../../services/health-runner';
+import { getArg, hasFlag } from '../parser';
+import type { CommandResult } from '../types';
+
+const STATUS_ICONS: Record<string, string> = {
+  healthy: '●',
+  degraded: '⚠',
+  unhealthy: '✗',
+  'no-checks': '—',
+  error: '✗',
+};
+
+const CHECK_ICONS: Record<string, string> = {
+  pass: '✓',
+  warn: '⚠',
+  fail: '✗',
+};
+
+function formatResult(result: HealthCheckResult): string {
+  const icon = STATUS_ICONS[result.status] || '?';
+  const lines: string[] = [];
+
+  if (result.status === 'no-checks') {
+    lines.push(`  ${result.moduleId} ${icon} no health check defined`);
+    return lines.join('\n');
+  }
+
+  if (result.status === 'error') {
+    lines.push(`  ${result.moduleId} ${icon} error: ${result.error}`);
+    return lines.join('\n');
+  }
+
+  const stateNote =
+    result.status === 'healthy' || result.status === 'degraded' ? ' → VERIFIED' : '';
+  lines.push(`  ${result.moduleId} ${icon} ${result.status}${stateNote}`);
+
+  for (const check of result.checks) {
+    const checkIcon = CHECK_ICONS[check.status] || '?';
+    lines.push(`    ${checkIcon} ${check.name.padEnd(20)} ${check.message}`);
+    if (check.details) {
+      lines.push(`      ${check.details}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Handle module health command
+ */
+export async function handleModuleHealth(
+  args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const db = getDb();
+  const debug = hasFlag(flags, 'debug');
+  const jsonOutput = hasFlag(flags, 'json');
+  const moduleId = getArg(args, 0);
+
+  let results: HealthCheckResult[];
+
+  if (moduleId) {
+    const result = await runModuleHealthCheck(moduleId, db, { debug });
+    results = [result];
+  } else {
+    results = await runAllHealthChecks(db, { debug });
+  }
+
+  if (jsonOutput) {
+    return {
+      success: true,
+      message: JSON.stringify({ modules: results }, null, 2),
+    };
+  }
+
+  if (results.length === 0) {
+    return {
+      success: true,
+      message: 'No deployed modules to check',
+    };
+  }
+
+  const output = results.map(formatResult).join('\n\n');
+  const allHealthy = results.every(
+    (r) => r.status === 'healthy' || r.status === 'degraded' || r.status === 'no-checks',
+  );
+
+  if (!allHealthy) {
+    return {
+      success: false,
+      error: output,
+    };
+  }
+
+  return {
+    success: true,
+    message: output,
+  };
+}