trickle-cli 0.1.0

package/src/commands/init.ts

@@ -0,0 +1,419 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+
+export interface InitOptions {
+  dir?: string;
+  python?: boolean;
+}
+
+interface ProjectInfo {
+  dir: string;
+  hasPackageJson: boolean;
+  hasTsConfig: boolean;
+  isPython: boolean;
+  framework: "express" | "fastapi" | "flask" | "django" | null;
+  entryFile: string | null;
+  packageJson: Record<string, unknown> | null;
+  tsConfig: Record<string, unknown> | null;
+}
+
+function detectProject(dir: string, forcePython: boolean): ProjectInfo {
+  const info: ProjectInfo = {
+    dir,
+    hasPackageJson: false,
+    hasTsConfig: false,
+    isPython: forcePython,
+    framework: null,
+    entryFile: null,
+    packageJson: null,
+    tsConfig: null,
+  };
+
+  // Check for package.json
+  const pkgPath = path.join(dir, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    info.hasPackageJson = true;
+    try {
+      info.packageJson = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    } catch {
+      // ignore parse errors
+    }
+  }
+
+  // Check for tsconfig.json
+  const tsPath = path.join(dir, "tsconfig.json");
+  if (fs.existsSync(tsPath)) {
+    info.hasTsConfig = true;
+    try {
+      // Strip comments (simple approach: remove // and /* */ comments)
+      const raw = fs.readFileSync(tsPath, "utf-8");
+      const cleaned = raw
+        .replace(/\/\/.*$/gm, "")
+        .replace(/\/\*[\s\S]*?\*\//g, "");
+      info.tsConfig = JSON.parse(cleaned);
+    } catch {
+      // ignore parse errors
+    }
+  }
+
+  // Check for Python project
+  if (
+    fs.existsSync(path.join(dir, "pyproject.toml")) ||
+    fs.existsSync(path.join(dir, "setup.py")) ||
+    fs.existsSync(path.join(dir, "requirements.txt"))
+  ) {
+    info.isPython = true;
+  }
+
+  // Detect framework from dependencies
+  if (info.packageJson) {
+    const deps = {
+      ...(info.packageJson.dependencies as Record<string, string> | undefined),
+      ...(info.packageJson.devDependencies as Record<string, string> | undefined),
+    };
+    if (deps.express) info.framework = "express";
+  }
+
+  if (info.isPython) {
+    // Check requirements.txt or pyproject.toml for framework
+    const reqPath = path.join(dir, "requirements.txt");
+    if (fs.existsSync(reqPath)) {
+      const reqs = fs.readFileSync(reqPath, "utf-8").toLowerCase();
+      if (reqs.includes("fastapi")) info.framework = "fastapi";
+      else if (reqs.includes("flask")) info.framework = "flask";
+      else if (reqs.includes("django")) info.framework = "django";
+    }
+  }
+
+  // Detect entry file
+  if (info.packageJson) {
+    const main = info.packageJson.main as string | undefined;
+    if (main && fs.existsSync(path.join(dir, main))) {
+      info.entryFile = main;
+    } else {
+      // Common entry points
+      for (const candidate of ["src/index.ts", "src/index.js", "index.ts", "index.js", "app.ts", "app.js", "server.ts", "server.js"]) {
+        if (fs.existsSync(path.join(dir, candidate))) {
+          info.entryFile = candidate;
+          break;
+        }
+      }
+    }
+  }
+
+  if (info.isPython && !info.entryFile) {
+    for (const candidate of ["app.py", "main.py", "server.py", "wsgi.py"]) {
+      if (fs.existsSync(path.join(dir, candidate))) {
+        info.entryFile = candidate;
+        break;
+      }
+    }
+  }
+
+  return info;
+}
+
+function createTrickleConfig(dir: string, info: ProjectInfo): boolean {
+  const configPath = path.join(dir, ".tricklerc.json");
+  if (fs.existsSync(configPath)) return false;
+
+  // Also check for package.json "trickle" field
+  if (info.packageJson && (info.packageJson as Record<string, unknown>).trickle) {
+    return false;
+  }
+
+  const config: Record<string, unknown> = {};
+
+  // Suggest stubs directory based on project structure
+  if (fs.existsSync(path.join(dir, "src"))) {
+    config.stubs = "src/";
+  } else {
+    config.stubs = ".";
+  }
+
+  // Default exclude patterns
+  config.exclude = ["node_modules", "dist", "build", "__pycache__"];
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return true;
+}
+
+function ensureTrickleDir(dir: string): string {
+  const trickleDir = path.join(dir, ".trickle");
+  if (!fs.existsSync(trickleDir)) {
+    fs.mkdirSync(trickleDir, { recursive: true });
+  }
+  return trickleDir;
+}
+
+function writeInitialTypes(trickleDir: string, isPython: boolean): void {
+  if (isPython) {
+    const pyPath = path.join(trickleDir, "types.pyi");
+    if (!fs.existsSync(pyPath)) {
+      fs.writeFileSync(
+        pyPath,
+        [
+          "# Auto-generated by trickle from runtime type observations",
+          "# Run your app to populate types, then: trickle codegen --python --out .trickle/types.pyi",
+          "#",
+          "# This file will be updated automatically when using: trickle codegen --python --watch --out .trickle/types.pyi",
+          "",
+          "from typing import TypedDict",
+          "",
+          "# Types will appear here after your app processes its first requests.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      );
+    }
+  } else {
+    const tsPath = path.join(trickleDir, "types.d.ts");
+    if (!fs.existsSync(tsPath)) {
+      fs.writeFileSync(
+        tsPath,
+        [
+          "// Auto-generated by trickle from runtime type observations",
+          "// Run your app to populate types, then: trickle codegen --out .trickle/types.d.ts",
+          "//",
+          "// This file will be updated automatically when using: trickle codegen --watch --out .trickle/types.d.ts",
+          "",
+          "// Types will appear here after your app processes its first requests.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      );
+    }
+
+    // Also create an api-client placeholder
+    const clientPath = path.join(trickleDir, "api-client.ts");
+    if (!fs.existsSync(clientPath)) {
+      fs.writeFileSync(
+        clientPath,
+        [
+          "// Auto-generated typed API client by trickle",
+          "// Run your app to populate types, then: trickle codegen --client --out .trickle/api-client.ts",
+          "",
+          "// A fully-typed fetch client will appear here after your app serves its first API requests.",
+          "",
+        ].join("\n"),
+        "utf-8",
+      );
+    }
+  }
+}
+
+function updateTsConfig(dir: string, info: ProjectInfo): boolean {
+  const tsConfigPath = path.join(dir, "tsconfig.json");
+
+  if (!info.hasTsConfig || !info.tsConfig) {
+    // No tsconfig — create a minimal one that includes .trickle
+    if (!info.isPython) {
+      const newConfig = {
+        compilerOptions: {
+          target: "ES2022",
+          module: "commonjs",
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          outDir: "./dist",
+          rootDir: "./src",
+        },
+        include: ["src", ".trickle"],
+      };
+      fs.writeFileSync(tsConfigPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+      return true;
+    }
+    return false;
+  }
+
+  // Read the raw file to preserve formatting as much as possible
+  const raw = fs.readFileSync(tsConfigPath, "utf-8");
+  const config = info.tsConfig;
+
+  // Check if .trickle is already included
+  const include = config.include as string[] | undefined;
+  if (include && include.some((p: string) => p === ".trickle" || p.startsWith(".trickle/"))) {
+    return false; // Already configured
+  }
+
+  // Add .trickle to include array
+  if (include) {
+    include.push(".trickle");
+  } else {
+    (config as Record<string, unknown>).include = ["src", ".trickle"];
+  }
+
+  fs.writeFileSync(tsConfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  return true;
+}
+
+function updatePackageJson(dir: string, info: ProjectInfo): { scriptsAdded: string[] } {
+  if (!info.hasPackageJson || !info.packageJson) {
+    return { scriptsAdded: [] };
+  }
+
+  const pkgPath = path.join(dir, "package.json");
+  const pkg = info.packageJson;
+  const scripts = (pkg.scripts as Record<string, string>) || {};
+  const added: string[] = [];
+
+  // Add trickle:dev script for watch mode
+  if (!scripts["trickle:dev"]) {
+    const outFile = info.isPython ? ".trickle/types.pyi" : ".trickle/types.d.ts";
+    const langFlag = info.isPython ? " --python" : "";
+    scripts["trickle:dev"] = `trickle codegen${langFlag} --watch --out ${outFile}`;
+    added.push("trickle:dev");
+  }
+
+  // Add trickle:client script for API client generation
+  if (!info.isPython && !scripts["trickle:client"]) {
+    scripts["trickle:client"] = "trickle codegen --client --out .trickle/api-client.ts";
+    added.push("trickle:client");
+  }
+
+  // Add trickle:mock script
+  if (!scripts["trickle:mock"]) {
+    scripts["trickle:mock"] = "trickle mock";
+    added.push("trickle:mock");
+  }
+
+  // Detect current start script and create a trickle-wrapped version
+  const startScript = scripts.start || scripts.dev;
+  if (startScript && !scripts["trickle:start"]) {
+    // Check if it's a node command we can add -r to
+    if (startScript.match(/\bnode\s/)) {
+      scripts["trickle:start"] = startScript.replace(/\bnode\s/, "node -r trickle-observe/register ");
+      added.push("trickle:start");
+    } else if (startScript.match(/\bts-node\s/)) {
+      scripts["trickle:start"] = startScript.replace(/\bts-node\s/, "ts-node -r trickle-observe/register ");
+      added.push("trickle:start");
+    } else if (startScript.match(/\bnodemon\s/)) {
+      scripts["trickle:start"] = startScript.replace(/\bnodemon\s/, "nodemon -r trickle-observe/register ");
+      added.push("trickle:start");
+    }
+  }
+
+  if (added.length > 0) {
+    pkg.scripts = scripts;
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+  }
+
+  return { scriptsAdded: added };
+}
+
+function updateGitignore(dir: string): boolean {
+  const giPath = path.join(dir, ".gitignore");
+  let content = "";
+
+  if (fs.existsSync(giPath)) {
+    content = fs.readFileSync(giPath, "utf-8");
+    if (content.includes(".trickle")) {
+      return false; // Already has it
+    }
+  }
+
+  const addition = content.endsWith("\n") || content === ""
+    ? ".trickle/\n"
+    : "\n.trickle/\n";
+
+  fs.writeFileSync(giPath, content + addition, "utf-8");
+  return true;
+}
+
+export async function initCommand(opts: InitOptions): Promise<void> {
+  const dir = path.resolve(opts.dir || ".");
+
+  console.log("");
+  console.log(chalk.bold("  trickle init"));
+  console.log("");
+
+  // Step 1: Detect project
+  const info = detectProject(dir, opts.python === true);
+
+  if (!info.hasPackageJson && !info.isPython) {
+    console.log(chalk.yellow("  No package.json or Python project detected."));
+    console.log(chalk.gray("  Run this command from your project root.\n"));
+    process.exit(1);
+  }
+
+  const lang = info.isPython ? "Python" : "Node.js";
+  console.log(chalk.gray(`  Detected: ${lang} project${info.framework ? ` (${info.framework})` : ""}`));
+  if (info.entryFile) {
+    console.log(chalk.gray(`  Entry: ${info.entryFile}`));
+  }
+  console.log("");
+
+  // Step 2: Create .tricklerc.json
+  const configCreated = createTrickleConfig(dir, info);
+  if (configCreated) {
+    console.log(`  ${chalk.green("+")} Created ${chalk.bold(".tricklerc.json")} — project config`);
+  } else {
+    console.log(`  ${chalk.gray("-")} .tricklerc.json already exists`);
+  }
+
+  // Step 3: Create .trickle directory
+  const trickleDir = ensureTrickleDir(dir);
+  console.log(`  ${chalk.green("+")} Created ${chalk.bold(".trickle/")} directory`);
+
+  // Step 3: Write initial type files
+  writeInitialTypes(trickleDir, info.isPython);
+  if (info.isPython) {
+    console.log(`  ${chalk.green("+")} Created ${chalk.bold(".trickle/types.pyi")} (type stubs)`);
+  } else {
+    console.log(`  ${chalk.green("+")} Created ${chalk.bold(".trickle/types.d.ts")} (type declarations)`);
+    console.log(`  ${chalk.green("+")} Created ${chalk.bold(".trickle/api-client.ts")} (typed API client)`);
+  }
+
+  // Step 4: Update tsconfig.json
+  if (!info.isPython) {
+    const tsUpdated = updateTsConfig(dir, info);
+    if (tsUpdated) {
+      if (info.hasTsConfig) {
+        console.log(`  ${chalk.green("~")} Updated ${chalk.bold("tsconfig.json")} — added .trickle to include`);
+      } else {
+        console.log(`  ${chalk.green("+")} Created ${chalk.bold("tsconfig.json")} with .trickle included`);
+      }
+    } else {
+      console.log(`  ${chalk.gray("-")} tsconfig.json already includes .trickle`);
+    }
+  }
+
+  // Step 5: Update package.json scripts
+  if (info.hasPackageJson) {
+    const { scriptsAdded } = updatePackageJson(dir, info);
+    if (scriptsAdded.length > 0) {
+      for (const name of scriptsAdded) {
+        console.log(`  ${chalk.green("+")} Added npm script: ${chalk.bold(name)}`);
+      }
+    }
+  }
+
+  // Step 6: Update .gitignore
+  const giUpdated = updateGitignore(dir);
+  if (giUpdated) {
+    console.log(`  ${chalk.green("~")} Updated ${chalk.bold(".gitignore")} — added .trickle/`);
+  }
+
+  // Step 7: Print next steps
+  console.log("");
+  console.log(chalk.bold("  Next steps:"));
+  console.log("");
+
+  const entryFile = info.entryFile || (info.isPython ? "app.py" : "app.js");
+  console.log(chalk.white("  1. Run your app with trickle (one command does everything):"));
+  console.log(chalk.cyan(`     trickle run ${entryFile}`));
+  console.log("");
+  console.log(chalk.white("  2. That's it! trickle auto-detects the runtime, observes types,"));
+  console.log(chalk.white("     and generates stubs from .tricklerc.json settings."));
+  console.log("");
+  console.log(chalk.gray("  Customize .tricklerc.json:"));
+  console.log(chalk.gray('     { "stubs": "src/", "annotate": "src/", "exclude": ["test"] }'));
+  console.log("");
+  console.log(chalk.gray("  Other commands:"));
+  console.log(chalk.gray("     trickle functions         — list observed functions"));
+  console.log(chalk.gray("     trickle types <name>      — see types + sample data"));
+  console.log(chalk.gray("     trickle annotate src/     — add type annotations to source files"));
+
+  console.log("");
+}

package/src/commands/mock.ts

@@ -0,0 +1,220 @@
+import * as http from "http";
+import chalk from "chalk";
+import { fetchMockConfig, MockRoute } from "../api-client";
+
+export interface MockOptions {
+  port?: string;
+  cors?: boolean;
+}
+
+/**
+ * Convert an Express-style path like `/api/users/:id` to a regex
+ * that captures named path params.
+ */
+function pathToRegex(routePath: string): { regex: RegExp; paramNames: string[] } {
+  const paramNames: string[] = [];
+  const pattern = routePath.replace(/:(\w+)/g, (_match, paramName) => {
+    paramNames.push(paramName);
+    return "([^/]+)";
+  });
+  return { regex: new RegExp(`^${pattern}$`), paramNames };
+}
+
+/**
+ * Build a description of the mock server routes for the startup banner.
+ */
+function formatRouteTable(routes: MockRoute[]): string {
+  const lines: string[] = [];
+  const methodColors: Record<string, (s: string) => string> = {
+    GET: chalk.green,
+    POST: chalk.yellow,
+    PUT: chalk.blue,
+    DELETE: chalk.red,
+    PATCH: chalk.magenta,
+  };
+
+  for (const route of routes) {
+    const color = methodColors[route.method] || chalk.white;
+    const method = color(route.method.padEnd(7));
+    const path = chalk.white(route.path);
+    const age = formatTimeAgo(route.observedAt);
+    lines.push(`    ${method} ${path}  ${chalk.gray(`(sample from ${age})`)}`);
+  }
+
+  return lines.join("\n");
+}
+
+function formatTimeAgo(isoDate: string): string {
+  try {
+    const date = new Date(isoDate.replace(" ", "T") + (isoDate.includes("Z") ? "" : "Z"));
+    const now = Date.now();
+    const diffSec = Math.floor((now - date.getTime()) / 1000);
+    if (diffSec < 60) return `${diffSec}s ago`;
+    const diffMin = Math.floor(diffSec / 60);
+    if (diffMin < 60) return `${diffMin}m ago`;
+    const diffHr = Math.floor(diffMin / 60);
+    if (diffHr < 24) return `${diffHr}h ago`;
+    const diffDay = Math.floor(diffHr / 24);
+    return `${diffDay}d ago`;
+  } catch {
+    return isoDate;
+  }
+}
+
+/**
+ * Substitute path params in sample output to match the requested values.
+ * For example, if the sample output has { id: 1 } but the request has :id = "42",
+ * replace numeric id fields with the requested value.
+ */
+function substituteSampleOutput(
+  sample: unknown,
+  paramValues: Record<string, string>,
+): unknown {
+  if (sample === null || sample === undefined) return sample;
+  if (typeof sample !== "object") return sample;
+
+  if (Array.isArray(sample)) {
+    return sample.map((item) => substituteSampleOutput(item, paramValues));
+  }
+
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(sample as Record<string, unknown>)) {
+    // If this key matches a path param name, substitute the value
+    if (key in paramValues) {
+      const paramVal = paramValues[key];
+      // Try to preserve the original type (number vs string)
+      if (typeof value === "number") {
+        const num = Number(paramVal);
+        result[key] = isNaN(num) ? paramVal : num;
+      } else {
+        result[key] = paramVal;
+      }
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = substituteSampleOutput(value, paramValues);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export async function mockCommand(opts: MockOptions): Promise<void> {
+  const port = parseInt(opts.port || "3000", 10);
+  const enableCors = opts.cors !== false;
+
+  // Fetch mock configuration from the backend
+  let routes: MockRoute[];
+  try {
+    const config = await fetchMockConfig();
+    routes = config.routes;
+  } catch (err: unknown) {
+    if (err instanceof Error) {
+      console.error(chalk.red(`\n  Error fetching mock config: ${err.message}\n`));
+    }
+    process.exit(1);
+  }
+
+  if (routes.length === 0) {
+    console.log("");
+    console.log(chalk.yellow("  No API routes found."));
+    console.log(chalk.gray("  Instrument your app and make some requests first."));
+    console.log("");
+    process.exit(0);
+  }
+
+  // Build route matchers
+  const matchers = routes.map((route) => {
+    const { regex, paramNames } = pathToRegex(route.path);
+    return { route, regex, paramNames };
+  });
+
+  // Create the mock HTTP server
+  const server = http.createServer((req, res) => {
+    const reqUrl = new URL(req.url || "/", `http://localhost:${port}`);
+    const reqMethod = (req.method || "GET").toUpperCase();
+    const reqPath = reqUrl.pathname;
+
+    // CORS headers
+    if (enableCors) {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    }
+
+    // Handle preflight
+    if (reqMethod === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    // Find matching route
+    for (const { route, regex, paramNames } of matchers) {
+      if (route.method !== reqMethod) continue;
+
+      const match = reqPath.match(regex);
+      if (!match) continue;
+
+      // Extract path params
+      const paramValues: Record<string, string> = {};
+      for (let i = 0; i < paramNames.length; i++) {
+        paramValues[paramNames[i]] = match[i + 1];
+      }
+
+      // Get sample output, substituting path param values
+      let output = route.sampleOutput;
+      if (output && Object.keys(paramValues).length > 0) {
+        output = substituteSampleOutput(output, paramValues);
+      }
+
+      // Log the request
+      const methodColor =
+        reqMethod === "GET" ? chalk.green :
+        reqMethod === "POST" ? chalk.yellow :
+        reqMethod === "PUT" ? chalk.blue :
+        reqMethod === "DELETE" ? chalk.red :
+        chalk.white;
+      console.log(
+        `  ${chalk.gray(new Date().toLocaleTimeString())} ${methodColor(reqMethod.padEnd(7))} ${reqPath} ${chalk.gray("→ 200")}`,
+      );
+
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(output ?? {}));
+      return;
+    }
+
+    // No route matched
+    console.log(
+      `  ${chalk.gray(new Date().toLocaleTimeString())} ${chalk.red(reqMethod.padEnd(7))} ${reqPath} ${chalk.red("→ 404")}`,
+    );
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not found", path: reqPath, method: reqMethod }));
+  });
+
+  server.listen(port, () => {
+    console.log("");
+    console.log(chalk.bold("  Trickle Mock Server"));
+    console.log("");
+    console.log(chalk.gray("  Routes (from runtime observations):"));
+    console.log(formatRouteTable(routes));
+    console.log("");
+    console.log(`  Listening on ${chalk.cyan(`http://localhost:${port}`)}`);
+    if (enableCors) {
+      console.log(chalk.gray("  CORS enabled (Access-Control-Allow-Origin: *)"));
+    }
+    console.log(chalk.gray("  Press Ctrl+C to stop.\n"));
+  });
+
+  // Handle graceful shutdown
+  process.on("SIGINT", () => {
+    console.log(chalk.gray("\n  Stopping mock server...\n"));
+    server.close(() => process.exit(0));
+  });
+
+  process.on("SIGTERM", () => {
+    server.close(() => process.exit(0));
+  });
+
+  // Keep process alive
+  await new Promise(() => {});
+}

package/src/commands/openapi.ts

@@ -0,0 +1,53 @@
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { fetchOpenApiSpec } from "../api-client";
+
+export interface OpenApiOptions {
+  out?: string;
+  env?: string;
+  title?: string;
+  apiVersion?: string;
+  server?: string;
+}
+
+export async function openapiCommand(opts: OpenApiOptions): Promise<void> {
+  try {
+    const spec = await fetchOpenApiSpec({
+      env: opts.env,
+      title: opts.title,
+      version: opts.apiVersion,
+      serverUrl: opts.server,
+    });
+
+    const json = JSON.stringify(spec, null, 2) + "\n";
+
+    if (opts.out) {
+      const outPath = path.resolve(opts.out);
+      const dir = path.dirname(outPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(outPath, json, "utf-8");
+      console.log("");
+      console.log(chalk.green(`  OpenAPI spec written to ${chalk.bold(opts.out)}`));
+
+      // Show summary
+      const specObj = spec as Record<string, unknown>;
+      const paths = specObj.paths as Record<string, unknown> || {};
+      const pathCount = Object.keys(paths).length;
+      let operationCount = 0;
+      for (const methods of Object.values(paths)) {
+        operationCount += Object.keys(methods as Record<string, unknown>).length;
+      }
+      console.log(chalk.gray(`  ${pathCount} path${pathCount !== 1 ? "s" : ""}, ${operationCount} operation${operationCount !== 1 ? "s" : ""}`));
+      console.log("");
+    } else {
+      process.stdout.write(json);
+    }
+  } catch (err: unknown) {
+    if (err instanceof Error) {
+      console.error(chalk.red(`\n  Error: ${err.message}\n`));
+    }
+  }
+}