@actuate-media/cli 0.4.1 → 0.5.0

package/src/commands/doctor.ts

@@ -1,74 +1,83 @@
-import { Command } from "commander";
-import { access, readdir, readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import chalk from "chalk";
+import { Command } from 'commander'
+import { access, readdir, readFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import chalk from 'chalk'
 import {
   buildDeploymentManifest,
   createDiagnosticReport,
   detectPackageManager,
   type DiagnosticReport,
-} from "../deployment/diagnostics.js";
+} from '../deployment/diagnostics.js'
 
 async function fileExists(path: string): Promise<boolean> {
   try {
-    await access(path);
-    return true;
+    await access(path)
+    return true
   } catch {
-    return false;
+    return false
   }
 }
 
 async function readSchemaModels(schemaPath: string): Promise<Set<string>> {
-  if (!(await fileExists(schemaPath))) return new Set();
-  const schema = await readFile(schemaPath, "utf-8");
-  const models = new Set<string>();
-  const modelRegex = /^model\s+(\w+)\s*\{/gm;
-  let match;
+  if (!(await fileExists(schemaPath))) return new Set()
+  const schema = await readFile(schemaPath, 'utf-8')
+  const models = new Set<string>()
+  const modelRegex = /^model\s+(\w+)\s*\{/gm
+  let match
   while ((match = modelRegex.exec(schema)) !== null) {
-    models.add(match[1]!);
+    models.add(match[1]!)
   }
-  return models;
+  return models
 }
 
 async function readSchemaContent(schemaPath: string): Promise<string> {
-  if (!(await fileExists(schemaPath))) return "";
-  return readFile(schemaPath, "utf-8");
+  if (!(await fileExists(schemaPath))) return ''
+  return readFile(schemaPath, 'utf-8')
 }
 
 async function readOptionalFile(path: string): Promise<string> {
-  if (!(await fileExists(path))) return "";
-  return readFile(path, "utf-8");
+  if (!(await fileExists(path))) return ''
+  return readFile(path, 'utf-8')
 }
 
 async function detectProjectPackageManager(): Promise<string> {
-  const entries = new Set(await readdir(process.cwd()));
-  return detectPackageManager(entries);
+  const entries = new Set(await readdir(process.cwd()))
+  return detectPackageManager(entries)
 }
 
 function printReport(title: string, report: DiagnosticReport): void {
-  console.log();
-  console.log(chalk.bold(title));
-  console.log(chalk.dim("─────────────────────────────────"));
+  console.log()
+  console.log(chalk.bold(title))
+  console.log(chalk.dim('─────────────────────────────────'))
   for (const check of report.checks) {
-    const icon = check.status === "pass" ? chalk.green("PASS") : check.status === "warn" ? chalk.yellow("WARN") : chalk.red("FAIL");
-    console.log(`${icon} ${check.label}: ${check.message}`);
-    if (check.fix) console.log(chalk.dim(`  Fix: ${check.fix}`));
-    if (check.docs) console.log(chalk.dim(`  Docs: ${check.docs}`));
+    const icon =
+      check.status === 'pass'
+        ? chalk.green('PASS')
+        : check.status === 'warn'
+          ? chalk.yellow('WARN')
+          : chalk.red('FAIL')
+    console.log(`${icon} ${check.label}: ${check.message}`)
+    if (check.fix) console.log(chalk.dim(`  Fix: ${check.fix}`))
+    if (check.docs) console.log(chalk.dim(`  Docs: ${check.docs}`))
   }
-  console.log(chalk.dim("─────────────────────────────────"));
-  console.log(`Status: ${report.status.toUpperCase()}`);
-  console.log();
+  console.log(chalk.dim('─────────────────────────────────'))
+  console.log(`Status: ${report.status.toUpperCase()}`)
+  console.log()
 }
 
-async function buildReport(schemaPath: string, configPath: string, mode: "doctor" | "deploy" = "doctor") {
-  const resolvedSchema = resolve(process.cwd(), schemaPath);
-  const resolvedConfig = resolve(process.cwd(), configPath);
+async function buildReport(
+  schemaPath: string,
+  configPath: string,
+  mode: 'doctor' | 'deploy' = 'doctor',
+) {
+  const resolvedSchema = resolve(process.cwd(), schemaPath)
+  const resolvedConfig = resolve(process.cwd(), configPath)
   const [schemaModels, schemaContent, configContent, packageManager] = await Promise.all([
     readSchemaModels(resolvedSchema),
     readSchemaContent(resolvedSchema),
     readOptionalFile(resolvedConfig),
     detectProjectPackageManager(),
-  ]);
+  ])
 
   return createDiagnosticReport({
     schemaModels,
@@ -78,92 +87,97 @@ async function buildReport(schemaPath: string, configPath: string, mode: "doctor
     packageManager,
     schemaPath,
     mode,
-  });
+  })
 }
 
 export function registerDoctorCommand(program: Command): void {
   program
-    .command("doctor")
-    .description("Run AI-friendly preflight checks for an Actuate CMS project")
-    .option("--schema <path>", "Path to schema.prisma", "prisma/schema.prisma")
-    .option("--config <path>", "Path to actuate.config.ts", "actuate.config.ts")
-    .option("--json", "Print machine-readable JSON")
+    .command('doctor')
+    .description('Run AI-friendly preflight checks for an Actuate CMS project')
+    .option('--schema <path>', 'Path to schema.prisma', 'prisma/schema.prisma')
+    .option('--config <path>', 'Path to actuate.config.ts', 'actuate.config.ts')
+    .option('--json', 'Print machine-readable JSON')
     .action(async (opts: { schema: string; config: string; json?: boolean }) => {
-      const report = await buildReport(opts.schema, opts.config, "doctor");
+      const report = await buildReport(opts.schema, opts.config, 'doctor')
       if (opts.json) {
-        console.log(JSON.stringify(report, null, 2));
+        console.log(JSON.stringify(report, null, 2))
       } else {
-        printReport("Actuate Doctor", report);
+        printReport('Actuate Doctor', report)
       }
-      if (report.status === "fail") process.exitCode = 1;
-    });
+      if (report.status === 'fail') process.exitCode = 1
+    })
 }
 
 export function registerDeployCheckCommand(program: Command): void {
   program
-    .command("deploy:check")
-    .description("Check production deployment readiness for Actuate CMS")
-    .option("--schema <path>", "Path to schema.prisma", "prisma/schema.prisma")
-    .option("--config <path>", "Path to actuate.config.ts", "actuate.config.ts")
-    .option("--json", "Print machine-readable JSON")
+    .command('deploy:check')
+    .description('Check production deployment readiness for Actuate CMS')
+    .option('--schema <path>', 'Path to schema.prisma', 'prisma/schema.prisma')
+    .option('--config <path>', 'Path to actuate.config.ts', 'actuate.config.ts')
+    .option('--json', 'Print machine-readable JSON')
     .action(async (opts: { schema: string; config: string; json?: boolean }) => {
-      const report = await buildReport(opts.schema, opts.config, "deploy");
+      const report = await buildReport(opts.schema, opts.config, 'deploy')
       if (opts.json) {
-        console.log(JSON.stringify({ ...report, manifest: buildDeploymentManifest() }, null, 2));
+        console.log(JSON.stringify({ ...report, manifest: buildDeploymentManifest() }, null, 2))
       } else {
-        printReport("Actuate Deploy Check", report);
-        console.log(chalk.dim("Run `actuate verify --full` after deployment succeeds."));
+        printReport('Actuate Deploy Check', report)
+        console.log(chalk.dim('Run `actuate verify --full` after deployment succeeds.'))
       }
-      if (report.status === "fail") process.exitCode = 1;
-    });
+      if (report.status === 'fail') process.exitCode = 1
+    })
 }
 
 export function registerVerifyCommand(program: Command): void {
   program
-    .command("verify")
-    .description("Verify an installed or deployed Actuate CMS project")
-    .option("--full", "Run the full verification checklist")
-    .option("--url <origin>", "Deployed site origin to verify, for example https://example.com")
-    .option("--json", "Print the deployment manifest as JSON")
+    .command('verify')
+    .description('Verify an installed or deployed Actuate CMS project')
+    .option('--full', 'Run the full verification checklist')
+    .option('--url <origin>', 'Deployed site origin to verify, for example https://example.com')
+    .option('--json', 'Print the deployment manifest as JSON')
     .action(async (opts: { full?: boolean; url?: string; json?: boolean }) => {
-      const manifest = buildDeploymentManifest();
+      const manifest = buildDeploymentManifest()
       if (opts.json) {
-        console.log(JSON.stringify(manifest, null, 2));
-        return;
+        console.log(JSON.stringify(manifest, null, 2))
+        return
       }
 
-      console.log();
-      console.log(chalk.bold(opts.full ? "Actuate Full Verification" : "Actuate Verification"));
-      console.log(chalk.dim("─────────────────────────────────"));
-      console.log(`PASS Manifest generated for ${manifest.packageScope} packages.`);
+      console.log()
+      console.log(chalk.bold(opts.full ? 'Actuate Full Verification' : 'Actuate Verification'))
+      console.log(chalk.dim('─────────────────────────────────'))
+      console.log(`PASS Manifest generated for ${manifest.packageScope} packages.`)
       if (!opts.url) {
-        console.log("WARN No --url provided, so remote health/admin endpoints were not checked.");
-        console.log(chalk.dim("Run `actuate verify --full --url https://your-site.com` after deployment."));
-        console.log();
-        return;
+        console.log('WARN No --url provided, so remote health/admin endpoints were not checked.')
+        console.log(
+          chalk.dim('Run `actuate verify --full --url https://your-site.com` after deployment.'),
+        )
+        console.log()
+        return
       }
 
-      const origin = opts.url.replace(/\/$/, "");
-      const healthUrl = `${origin}${manifest.routes.apiHealth}`;
-      const adminUrl = `${origin}${manifest.routes.adminDefault}`;
-      let failed = false;
+      const origin = opts.url.replace(/\/$/, '')
+      const healthUrl = `${origin}${manifest.routes.apiHealth}`
+      const adminUrl = `${origin}${manifest.routes.adminDefault}`
+      let failed = false
 
-      for (const [label, url] of [['Health', healthUrl], ['Admin', adminUrl]] as const) {
+      for (const [label, url] of [
+        ['Health', healthUrl],
+        ['Admin', adminUrl],
+      ] as const) {
         try {
-          const response = await fetch(url, { method: 'GET' });
+          const response = await fetch(url, { method: 'GET' })
           if (response.ok || response.status === 302 || response.status === 401) {
-            console.log(`PASS ${label} route responded at ${url}.`);
+            console.log(`PASS ${label} route responded at ${url}.`)
           } else {
-            failed = true;
-            console.log(`FAIL ${label} route returned HTTP ${response.status} at ${url}.`);
+            failed = true
+            console.log(`FAIL ${label} route returned HTTP ${response.status} at ${url}.`)
           }
         } catch (error) {
-          failed = true;
-          const message = error instanceof Error ? error.message : String(error);
-          console.log(`FAIL ${label} route could not be reached at ${url}: ${message}`);
+          failed = true
+          const message = error instanceof Error ? error.message : String(error)
+          console.log(`FAIL ${label} route could not be reached at ${url}: ${message}`)
         }
       }
-      console.log();
-      if (failed) process.exitCode = 1;
-    });
+      console.log()
+      if (failed) process.exitCode = 1
+    })
 }

package/src/commands/export.ts

@@ -1,131 +1,121 @@
-import { Command } from "commander";
-import { writeFile } from "node:fs/promises";
-import ora from "ora";
-import { logger } from "../utils/logger.js";
+import { Command } from 'commander'
+import { writeFile } from 'node:fs/promises'
+import ora from 'ora'
+import { logger } from '../utils/logger.js'
 
 interface ExportOptions {
-  collection?: string;
-  format: string;
-  output?: string;
-  includeDrafts?: boolean;
+  collection?: string
+  format: string
+  output?: string
+  includeDrafts?: boolean
 }
 
 function buildOutputPath(options: ExportOptions): string {
-  if (options.output) return options.output;
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const ext = options.format === "csv" ? "csv" : "json";
-  return `actuate-export-${timestamp}.${ext}`;
+  if (options.output) return options.output
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+  const ext = options.format === 'csv' ? 'csv' : 'json'
+  return `actuate-export-${timestamp}.${ext}`
 }
 
 function jsonToCsv(docs: any[]): string {
-  if (docs.length === 0) return "";
+  if (docs.length === 0) return ''
 
-  const keySet = new Set<string>();
+  const keySet = new Set<string>()
   for (const doc of docs) {
-    keySet.add("id");
-    keySet.add("collection");
-    keySet.add("status");
-    keySet.add("createdAt");
-    keySet.add("updatedAt");
-    if (doc.data && typeof doc.data === "object") {
+    keySet.add('id')
+    keySet.add('collection')
+    keySet.add('status')
+    keySet.add('createdAt')
+    keySet.add('updatedAt')
+    if (doc.data && typeof doc.data === 'object') {
       for (const key of Object.keys(doc.data)) {
-        keySet.add(`data.${key}`);
+        keySet.add(`data.${key}`)
       }
     }
   }
-  const headers = Array.from(keySet);
+  const headers = Array.from(keySet)
 
   const escapeCsvValue = (val: unknown): string => {
-    if (val === null || val === undefined) return "";
-    const str = typeof val === "object" ? JSON.stringify(val) : String(val);
-    if (str.includes(",") || str.includes('"') || str.includes("\n")) {
-      return `"${str.replace(/"/g, '""')}"`;
+    if (val === null || val === undefined) return ''
+    const str = typeof val === 'object' ? JSON.stringify(val) : String(val)
+    if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+      return `"${str.replace(/"/g, '""')}"`
     }
-    return str;
-  };
+    return str
+  }
 
   const rows = docs.map((doc) => {
     return headers
       .map((header) => {
-        if (header.startsWith("data.")) {
-          const field = header.slice(5);
-          return escapeCsvValue(doc.data?.[field]);
+        if (header.startsWith('data.')) {
+          const field = header.slice(5)
+          return escapeCsvValue(doc.data?.[field])
         }
-        return escapeCsvValue(doc[header]);
+        return escapeCsvValue(doc[header])
       })
-      .join(",");
-  });
+      .join(',')
+  })
 
-  return [headers.join(","), ...rows].join("\n");
+  return [headers.join(','), ...rows].join('\n')
 }
 
 async function runExport(options: ExportOptions): Promise<void> {
-  const target = options.collection ?? "all collections";
-  const spinner = ora(`Exporting ${target}…`).start();
+  const target = options.collection ?? 'all collections'
+  const spinner = ora(`Exporting ${target}…`).start()
 
   try {
-    const { getDB } = await import("@actuate-media/cms-core");
-    const db = getDB<any>();
+    const { getDB } = await import('@actuate-media/cms-core')
+    const db = getDB<any>()
 
-    const where: any = { deletedAt: null };
+    const where: any = { deletedAt: null }
 
     if (options.collection) {
-      where.collection = options.collection;
+      where.collection = options.collection
     }
 
     if (!options.includeDrafts) {
-      where.status = "PUBLISHED";
+      where.status = 'PUBLISHED'
     }
 
     const docs = await db.document.findMany({
       where,
-      orderBy: { createdAt: "desc" },
-    });
+      orderBy: { createdAt: 'desc' },
+    })
 
     if (docs.length === 0) {
-      spinner.warn("No documents found matching the criteria.");
-      return;
+      spinner.warn('No documents found matching the criteria.')
+      return
     }
 
-    const outputPath = buildOutputPath(options);
-    let content: string;
+    const outputPath = buildOutputPath(options)
+    let content: string
 
-    if (options.format === "csv") {
-      content = jsonToCsv(docs);
+    if (options.format === 'csv') {
+      content = jsonToCsv(docs)
     } else {
-      content = JSON.stringify(docs, null, 2);
+      content = JSON.stringify(docs, null, 2)
     }
 
-    await writeFile(outputPath, content, "utf-8");
-    spinner.succeed(`Exported ${docs.length} documents to ${outputPath}`);
+    await writeFile(outputPath, content, 'utf-8')
+    spinner.succeed(`Exported ${docs.length} documents to ${outputPath}`)
   } catch (err) {
-    spinner.fail("Export failed.");
-    const message = err instanceof Error ? err.message : String(err);
-    logger.error(message);
-    process.exit(1);
+    spinner.fail('Export failed.')
+    const message = err instanceof Error ? err.message : String(err)
+    logger.error(message)
+    process.exit(1)
   }
 }
 
 export function registerExportCommand(program: Command): void {
   program
-    .command("export")
-    .description("Export content to JSON or CSV files")
-    .option(
-      "-c, --collection <slug>",
-      "Export only the specified collection (default: all)",
-    )
-    .option(
-      "-f, --format <type>",
-      "Output format: json or csv",
-      "json",
-    )
-    .option(
-      "-o, --output <path>",
-      "Output file path (default: actuate-export-{timestamp}.{format})",
-    )
+    .command('export')
+    .description('Export content to JSON or CSV files')
+    .option('-c, --collection <slug>', 'Export only the specified collection (default: all)')
+    .option('-f, --format <type>', 'Output format: json or csv', 'json')
     .option(
-      "--include-drafts",
-      "Include draft documents (default: published only)",
+      '-o, --output <path>',
+      'Output file path (default: actuate-export-{timestamp}.{format})',
     )
-    .action(runExport);
+    .option('--include-drafts', 'Include draft documents (default: published only)')
+    .action(runExport)
 }

package/src/commands/generate.ts

@@ -1,28 +1,26 @@
-import { Command } from "commander";
-import ora from "ora";
-import { logger } from "../utils/logger.js";
+import { Command } from 'commander'
+import ora from 'ora'
+import { logger } from '../utils/logger.js'
 
 async function runGenerate(): Promise<void> {
-  const spinner = ora("Generating TypeScript types from schema…").start();
+  const spinner = ora('Generating TypeScript types from schema…').start()
 
   try {
     // Dynamically import the codegen module from cms-core
-    const { runCodegen } = await import("@actuate-media/cms-core/codegen");
-    await runCodegen();
-    spinner.succeed("Type generation complete.");
+    const { runCodegen } = await import('@actuate-media/cms-core/codegen')
+    await runCodegen()
+    spinner.succeed('Type generation complete.')
   } catch (err) {
-    spinner.fail("Type generation failed.");
-    const message = err instanceof Error ? err.message : String(err);
-    logger.error(message);
-    process.exitCode = 1;
+    spinner.fail('Type generation failed.')
+    const message = err instanceof Error ? err.message : String(err)
+    logger.error(message)
+    process.exitCode = 1
   }
 }
 
 export function registerGenerateCommand(program: Command): void {
   program
-    .command("generate")
-    .description(
-      "Run the TypeScript type generator from the cms-core codegen module",
-    )
-    .action(runGenerate);
+    .command('generate')
+    .description('Run the TypeScript type generator from the cms-core codegen module')
+    .action(runGenerate)
 }