clckernel 1.2.6

package/tools/check_db_efficiency.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+Backend Database Efficiency & N+1 Performance Guard
+AST scanner detecting:
+1. Database queries executed inside loops (N+1 query pattern in SQLAlchemy, Django ORM, SQLModel)
+2. Blocking time.sleep() calls inside async route handlers/coroutines
+3. Unbounded .all() queries missing pagination/limits in API routes
+4. Missing eager loading patterns (select_related, prefetch_related, selectinload, joinedload)
+
+Self-contained: uses only Python standard library (ast, subprocess, pathlib).
+"""
+from __future__ import annotations
+
+import ast
+import os
+import pathlib
+import subprocess
+import sys
+
+
+QUERY_METHODS = {
+    "filter", "get", "all", "first", "execute", "scalars", "scalar",
+    "fetch", "fetchall", "fetchone", "query", "raw"
+}
+
+QUERY_CALLERS = {
+    "db", "session", "objects", "cursor", "connection", "repo", "repository"
+}
+
+
+class LoopQueryVisitor(ast.NodeVisitor):
+    def __init__(self, filename: str):
+        self.filename = filename
+        self.violations: list[dict] = []
+        self._loop_depth = 0
+        self._is_async_func = False
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef):
+        prev = self._is_async_func
+        self._is_async_func = True
+        self.generic_visit(node)
+        self._is_async_func = prev
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        prev = self._is_async_func
+        self._is_async_func = False
+        self.generic_visit(node)
+        self._is_async_func = prev
+
+    def visit_For(self, node: ast.For):
+        self._loop_depth += 1
+        self.generic_visit(node)
+        self._loop_depth -= 1
+
+    def visit_While(self, node: ast.While):
+        self._loop_depth += 1
+        self.generic_visit(node)
+        self._loop_depth -= 1
+
+    def visit_ListComp(self, node: ast.ListComp):
+        self._loop_depth += 1
+        self.generic_visit(node)
+        self._loop_depth -= 1
+
+    def visit_DictComp(self, node: ast.DictComp):
+        self._loop_depth += 1
+        self.generic_visit(node)
+        self._loop_depth -= 1
+
+    def visit_GeneratorExp(self, node: ast.GeneratorExp):
+        self._loop_depth += 1
+        self.generic_visit(node)
+        self._loop_depth -= 1
+
+    def visit_Call(self, node: ast.Call):
+        # 1. Detect time.sleep in async def
+        if self._is_async_func:
+            if isinstance(node.func, ast.Attribute) and node.func.attr == "sleep":
+                if isinstance(node.func.value, ast.Name) and node.func.value.id == "time":
+                    self.violations.append({
+                        "lineNo": node.lineno,
+                        "rule": "sync-blocking-sleep",
+                        "message": "Blocking time.sleep() called inside async function. Use 'await asyncio.sleep()' instead to avoid starving the event loop."
+                    })
+
+        # 2. Detect DB queries inside loops (N+1 query hazard)
+        if self._loop_depth > 0:
+            if isinstance(node.func, ast.Attribute):
+                attr_name = node.func.attr
+                val = node.func.value
+
+                # Match session.execute(), db.query(), Model.objects.filter(), etc.
+                is_db_call = False
+                caller_name = ""
+
+                if isinstance(val, ast.Name):
+                    caller_name = val.id.lower()
+                    if caller_name in QUERY_CALLERS or attr_name in QUERY_METHODS:
+                        is_db_call = True
+                elif isinstance(val, ast.Attribute):
+                    caller_name = val.attr.lower()
+                    if caller_name in QUERY_CALLERS or attr_name in QUERY_METHODS:
+                        is_db_call = True
+
+                if is_db_call and attr_name in QUERY_METHODS:
+                    self.violations.append({
+                        "lineNo": node.lineno,
+                        "rule": "db-query-in-loop",
+                        "message": f"Database query call '.{attr_name}()' detected inside loop/comprehension. Causes N+1 performance bottleneck. Use bulk queries or eager loading (selectinload/joinedload/select_related)."
+                    })
+
+        self.generic_visit(node)
+
+
+def check(target_dir: str | None = None) -> dict:
+    dir_path = pathlib.Path(target_dir or os.getcwd()).resolve()
+
+    # Get changed python files
+    files: list[str] = []
+    try:
+        out = subprocess.check_output(
+            ["git", "diff", "--name-only", "HEAD~1"],
+            cwd=dir_path,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        files = [f.strip() for f in out.splitlines() if f.strip().endswith(".py")]
+    except Exception:
+        try:
+            out = subprocess.check_output(
+                ["git", "diff", "--name-only", "--cached"],
+                cwd=dir_path,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            files = [f.strip() for f in out.splitlines() if f.strip().endswith(".py")]
+        except Exception:
+            return {
+                "exit_code": 0,
+                "skipped": True,
+                "name": "check_db_efficiency",
+                "data": {"message": "No git diff available"}
+            }
+
+    if not files:
+        return {
+            "exit_code": 0,
+            "skipped": False,
+            "name": "check_db_efficiency",
+            "data": {"violations": {}, "message": "No Python backend files changed"}
+        }
+
+    violations: dict[str, list[dict]] = {}
+
+    for file_rel in files:
+        file_path = dir_path / file_rel
+        if not file_path.is_file():
+            continue
+
+        try:
+            source = file_path.read_text(encoding="utf-8")
+            tree = ast.parse(source, filename=str(file_path))
+        except Exception:
+            continue
+
+        visitor = LoopQueryVisitor(file_rel)
+        visitor.visit(tree)
+
+        if visitor.violations:
+            violations[file_rel] = visitor.violations
+
+    total_count = sum(len(v) for v in violations.values())
+    return {
+        "exit_code": 1 if total_count > 0 else 0,
+        "skipped": False,
+        "name": "check_db_efficiency",
+        "data": {
+            "violations": violations,
+            "message": f"{total_count} DB efficiency / N+1 issue(s) found in {len(violations)} file(s)"
+            if total_count > 0 else "All database efficiency & performance checks passed"
+        }
+    }
+
+
+if __name__ == "__main__":
+    import json
+    target = sys.argv[1] if len(sys.argv) > 1 else None
+    result = check(target)
+    print(json.dumps(result, indent=2))
+    sys.exit(result["exit_code"])

package/tools/check_migrations.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+Alembic / Django Migration Idempotency & Safety Guard
+Checks that database migration scripts follow safe practices:
+  - Migrations have both upgrade() and downgrade()
+  - No destructive operations without downgrade safeguards
+  - Migration files are not empty
+  - Django migrations reference existing model classes
+Self-contained: uses only Python stdlib (ast, pathlib, subprocess, json).
+"""
+from __future__ import annotations
+
+import ast
+import json
+import os
+import pathlib
+import re
+import subprocess
+import sys
+
+
+def _get_changed_files(target_dir: str) -> list[str] | None:
+    """Return changed files from git diff, or None on failure."""
+    for ref in ("HEAD~1", "--cached"):
+        try:
+            args = ["git", "diff", "--name-only"]
+            if ref == "--cached":
+                args.append("--cached")
+            else:
+                args.append(ref)
+            out = subprocess.check_output(
+                args, cwd=target_dir,
+                stderr=subprocess.DEVNULL, text=True,
+            )
+            files = [f.strip() for f in out.splitlines() if f.strip()]
+            if files:
+                return files
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            continue
+    return None
+
+
+def _find_migration_files(target_dir: str) -> list[str]:
+    """Find all migration files in the project."""
+    root = pathlib.Path(target_dir)
+    migrations: list[str] = []
+
+    # Alembic: alembic/versions/*.py
+    alembic_versions = root / "alembic" / "versions"
+    if alembic_versions.is_dir():
+        for f in sorted(alembic_versions.glob("*.py")):
+            migrations.append(str(f.relative_to(root)))
+
+    # Django: */migrations/*.py
+    for migrations_dir in root.rglob("migrations"):
+        if migrations_dir.is_dir() and migrations_dir != root:
+            # Skip hidden dirs and __pycache__
+            rel = str(migrations_dir.relative_to(root))
+            if rel.startswith(".") or "__pycache__" in rel:
+                continue
+            for f in sorted(migrations_dir.glob("*.py")):
+                if f.name != "__init__.py":
+                    migrations.append(str(f.relative_to(root)))
+
+    return migrations
+
+
+def _check_alembic_migration(filepath: str, content: str) -> list[dict]:
+    """Check an Alembic migration file for issues."""
+    violations: list[dict] = []
+
+    # Check for upgrade function
+    if "def upgrade(" not in content:
+        violations.append({
+            "lineNo": 0,
+            "rule": "missing-upgrade",
+            "reason": "Migration has no upgrade() function",
+        })
+
+    # Check for downgrade function
+    if "def downgrade(" not in content:
+        violations.append({
+            "lineNo": 0,
+            "rule": "missing-downgrade",
+            "reason": "Migration has no downgrade() function — rollback impossible",
+        })
+
+    # Check for destructive operations
+    destructive_patterns = [
+        (r"\.drop_table\(", "DROP TABLE", "Destructive: table drop without safeguard"),
+        (r"\.drop_column\(", "DROP COLUMN", "Destructive: column drop without safeguard"),
+        (r"\.drop_index\(", "DROP INDEX", "Destructive: index drop"),
+        (r"batch_alter_table.*\.drop_column", "BATCH DROP COLUMN", "Batch column drop"),
+    ]
+    for pattern, label, reason in destructive_patterns:
+        if re.search(pattern, content):
+            # Check if there's a corresponding downgrade
+            if "def downgrade(" in content:
+                downgrade_section = content.split("def downgrade(")[1] if "def downgrade(" in content else ""
+                if label.lower().replace(" ", "_") not in downgrade_section.lower().replace(" ", "_"):
+                    # More lenient: just flag it
+                    violations.append({
+                        "lineNo": 0,
+                        "rule": f"destructive-{label.lower().replace(' ', '_')}",
+                        "reason": f"{reason} — verify downgrade covers this",
+                    })
+
+    return violations
+
+
+def _check_django_migration(filepath: str, content: str) -> list[dict]:
+    """Check a Django migration file for issues."""
+    violations: list[dict] = []
+
+    # Check for empty migration
+    if len(content.strip()) < 50:
+        violations.append({
+            "lineNo": 0,
+            "rule": "empty-migration",
+            "reason": "Migration file appears empty or near-empty",
+        })
+
+    # Check for RunPython without reverse_code
+    if "RunPython(" in content:
+        # Find RunPython calls and check for reverse_code
+        run_python_pattern = re.compile(r"RunPython\(([^)]*)\)")
+        for match in run_python_pattern.finditer(content):
+            args = match.group(1)
+            if "reverse_code" not in args and "run_python" not in args.lower():
+                violations.append({
+                    "lineNo": content[:match.start()].count("\n") + 1,
+                    "rule": "run-python-no-reverse",
+                    "reason": "RunPython without reverse_code — rollback may fail",
+                })
+
+    # Check for RunSQL without reverse_sql
+    if "RunSQL(" in content:
+        run_sql_pattern = re.compile(r"RunSQL\(([^)]*)\)")
+        for match in run_sql_pattern.finditer(content):
+            args = match.group(1)
+            if "reverse_sql" not in args:
+                violations.append({
+                    "lineNo": content[:match.start()].count("\n") + 1,
+                    "rule": "run-sql-no-reverse",
+                    "reason": "RunSQL without reverse_sql — rollback may fail",
+                })
+
+    return violations
+
+
+def check(target_dir: str | None = None) -> dict:
+    """
+    Check migration files for idempotency and safety issues.
+
+    Returns:
+        dict with keys: exit_code, skipped, name, data
+        data.violations maps filepath -> list of {lineNo, rule, reason}
+    """
+    dir_path = target_dir or os.getcwd()
+
+    changed_files = _get_changed_files(dir_path)
+    if changed_files is None:
+        return {
+            "exit_code": 0, "skipped": True, "name": "check_migrations",
+            "data": {"violations": {}, "message": "No git diff available"},
+        }
+
+    migration_files = _find_migration_files(dir_path)
+    if not migration_files:
+        return {
+            "exit_code": 0, "skipped": False, "name": "check_migrations",
+            "data": {"violations": {}, "message": "No migration files found"},
+        }
+
+    # Only check migrations that were changed
+    changed_migrations = [f for f in migration_files if f in changed_files]
+    if not changed_migrations:
+        return {
+            "exit_code": 0, "skipped": False, "name": "check_migrations",
+            "data": {"violations": {}, "message": "No migration files were changed"},
+        }
+
+    violations: dict[str, list[dict]] = {}
+
+    for filepath in changed_migrations:
+        full_path = pathlib.Path(dir_path) / filepath
+        try:
+            content = full_path.read_text(encoding="utf-8", errors="replace")
+        except (OSError, PermissionError):
+            continue
+
+        # Determine migration framework
+        if "/alembic/" in filepath or "alembic" in filepath:
+            file_violations = _check_alembic_migration(filepath, content)
+        elif "/migrations/" in filepath:
+            file_violations = _check_django_migration(filepath, content)
+        else:
+            file_violations = []
+
+        if file_violations:
+            violations[filepath] = file_violations
+
+    total = sum(len(v) for v in violations.values())
+    if total:
+        msg = (
+            f"{total} migration issue(s) found in "
+            f"{len(violations)} file(s)"
+        )
+    else:
+        msg = "All migration checks passed"
+
+    return {
+        "exit_code": 1 if total else 0,
+        "skipped": False,
+        "name": "check_migrations",
+        "data": {"violations": violations, "message": msg},
+    }
+
+
+if __name__ == "__main__":
+    result = check(sys.argv[1] if len(sys.argv) > 1 else None)
+    print(json.dumps(result, indent=2))
+    sys.exit(result["exit_code"])

package/tools/check_performance.js

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * Performance & Next/Image Guard
+ * Checks next/image usage, detects raw <img> tags, and validates dynamic import patterns.
+ * Self-contained: uses only Node.js built-ins.
+ *
+ * @param {string} targetDir - Directory to scan (defaults to cwd)
+ * @returns {{ exitCode: number, skipped: boolean, name: string, data: object }}
+ */
+const check = async function checkPerformance(targetDir) {
+  const fs = require('fs');
+  const path = require('path');
+  const { execSync } = require('child_process');
+
+  const dir = targetDir || process.cwd();
+
+  // Verify this is a Next.js project
+  const pkgPath = path.join(dir, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return { exitCode: 0, skipped: true, name: 'check_performance', data: { violations: {}, message: 'No package.json found — skipping performance check' } };
+  }
+
+  let isNext;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    isNext = Boolean(deps['next']);
+  } catch {
+    isNext = false;
+  }
+
+  if (!isNext) {
+    return { exitCode: 0, skipped: true, name: 'check_performance', data: { violations: {}, message: 'Not a Next.js project — skipping' } };
+  }
+
+  // Collect changed files
+  let files;
+  try {
+    const out = execSync('git diff --name-only HEAD~1', {
+      cwd: dir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe']
+    });
+    files = out.split('\n').filter(f => /\.(tsx|jsx|ts|js)$/.test(f.trim()));
+  } catch {
+    try {
+      const out = execSync('git diff --name-only --cached', {
+        cwd: dir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe']
+      });
+      files = out.split('\n').filter(f => /\.(tsx|jsx|ts|js)$/.test(f.trim()));
+    } catch {
+      return { exitCode: 0, skipped: true, name: 'check_performance', data: { violations: {}, message: 'No git diff available' } };
+    }
+  }
+
+  if (!files || files.length === 0) {
+    return { exitCode: 0, skipped: false, name: 'check_performance', data: { violations: {}, message: 'No files changed' } };
+  }
+
+  const violations = {};
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    if (!fs.existsSync(filePath)) continue;
+
+    let content;
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const fileViolations = [];
+
+    // Check: raw <img> tags (should use next/image)
+    const imgMatches = content.match(/<img\b[^>]*>/gi) || [];
+    if (imgMatches.length > 0) {
+      // Exclude commented-out images
+      const activeImgs = imgMatches.filter(m => !/^\s*\/\//.test(m));
+      if (activeImgs.length > 0) {
+        fileViolations.push({
+          lineNo: 0,
+          rule: 'raw-img',
+          message: `${activeImgs.length} raw <img> tag(s) — use next/image for optimization`,
+        });
+      }
+    }
+
+    // Check: large inline data URIs in src attributes
+    if (/src\s*=\s*['"]data:image\/[^'"]{1000,}/.test(content)) {
+      fileViolations.push({
+        lineNo: 0,
+        rule: 'data-uri',
+        message: 'Large inline data URI in image src — use next/image with a proper source',
+      });
+    }
+
+    // Check: dynamic imports without loading="lazy" equivalent
+    // In Next.js, dynamic() is fine but verify it's used
+    const hasDynamicImport = /dynamic\s*\(/.test(content) || /React\.lazy\s*\(/.test(content);
+    const hasHeavyLibImport = /from\s+['"](moment|lodash|date-fns|@mui|antd|@chakra-ui)['"]/.test(content);
+    if (hasHeavyLibImport && !hasDynamicImport) {
+      fileViolations.push({
+        lineNo: 0,
+        rule: 'heavy-import',
+        message: 'Heavy library imported statically — use next/dynamic for code splitting',
+      });
+    }
+
+    // Check: barrel file re-exports that hurt tree-shaking
+    if (/export\s*\*\s*from/.test(content) && file.includes('index.')) {
+      fileViolations.push({
+        lineNo: 0,
+        rule: 'barrel-export',
+        message: 'Barrel re-export (export *) in index file — may prevent tree-shaking',
+      });
+    }
+
+    if (fileViolations.length > 0) {
+      violations[file] = fileViolations;
+    }
+  }
+
+  const totalCount = Object.values(violations).flat().length;
+  return {
+    exitCode: totalCount > 0 ? 1 : 0,
+    skipped: false,
+    name: 'check_performance',
+    data: {
+      violations,
+      message: totalCount > 0
+        ? `${totalCount} performance issue(s) found in ${Object.keys(violations).length} file(s)`
+        : 'All performance checks passed',
+    },
+  };
+};
+module.exports = check;
+
+if (require.main === module) {
+  check(process.argv[2]).then(result => {
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.exitCode);
+  });
+}

package/tools/check_responsive.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/**
+ * Responsive & Web Adaptability Guard
+ * Scans changed frontend files (.tsx, .jsx, .vue, .astro, .html, .css) for:
+ * 1. Hardcoded non-responsive fixed widths (e.g. w-[1200px], min-w-[1024px] without breakpoints)
+ * 2. Inline fixed pixel dimensions breaking mobile layouts
+ * 3. Mobile touch-target accessibility issues (clickable elements < 44px without padding)
+ * 4. Missing or restrictive viewport configurations in root layouts
+ *
+ * Self-contained: uses only Node.js built-ins.
+ *
+ * @param {string} targetDir - Directory to scan (defaults to cwd)
+ * @returns {{ exitCode: number, skipped: boolean, name: string, data: object }}
+ */
+const check = async function checkResponsive(targetDir) {
+  const fs = require('fs');
+  const path = require('path');
+  const { execSync } = require('child_process');
+
+  const dir = targetDir || process.cwd();
+
+  let files;
+  try {
+    const out = execSync('git diff --name-only HEAD~1', {
+      cwd: dir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe']
+    });
+    files = out.split('\n').filter(f => /\.(tsx|jsx|vue|astro|html|css)$/.test(f.trim()));
+  } catch {
+    try {
+      const out = execSync('git diff --name-only --cached', {
+        cwd: dir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe']
+      });
+      files = out.split('\n').filter(f => /\.(tsx|jsx|vue|astro|html|css)$/.test(f.trim()));
+    } catch {
+      return { exitCode: 0, skipped: true, name: 'check_responsive', data: { violations: {}, message: 'No git diff available' } };
+    }
+  }
+
+  if (!files || files.length === 0) {
+    return { exitCode: 0, skipped: false, name: 'check_responsive', data: { violations: {}, message: 'No frontend files changed' } };
+  }
+
+  const violations = {};
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    if (!fs.existsSync(filePath)) continue;
+
+    let content;
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    const lines = content.split('\n');
+    const fileViolations = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // 1. Check for hardcoded arbitrary desktop fixed widths without responsive modifiers
+      // e.g. w-[1200px], min-w-[1000px] without sm:, md:, lg:, xl:, 2xl: prefixes
+      const hardcodedWidthMatch = /(?<!(?:sm|md|lg|xl|2xl):)(?:min-w|w)-\[(\d{3,4})px\]/g;
+      let match;
+      while ((match = hardcodedWidthMatch.exec(line)) !== null) {
+        const px = parseInt(match[1], 10);
+        if (px >= 640 && !line.includes('max-w-') && !line.includes('overflow-x-auto') && !line.includes('overflow-auto')) {
+          fileViolations.push({
+            lineNo: i + 1,
+            rule: 'responsive-fixed-width',
+            message: `Hardcoded fixed width "${match[0]}" may cause horizontal overflow on mobile/tablet. Use max-w-* or responsive breakpoints (e.g., md:${match[0]}).`
+          });
+        }
+      }
+
+      // 2. Check for inline fixed pixel styles
+      if (/style\s*=\s*\{\{\s*width:\s*['"](\d{3,4})px['"]/i.test(line)) {
+        fileViolations.push({
+          lineNo: i + 1,
+          rule: 'inline-fixed-width',
+          message: 'Hardcoded inline style width breaks mobile responsiveness. Use responsive CSS/Tailwind classes.'
+        });
+      }
+
+      // 3. Check for restrictive user-scalable=no or maximum-scale=1 in viewport meta
+      if (/name\s*=\s*['"]viewport['"]/i.test(line) && /user-scalable\s*=\s*no|maximum-scale\s*=\s*1(?:\.0)?/i.test(line)) {
+        fileViolations.push({
+          lineNo: i + 1,
+          rule: 'a11y-viewport-scalable',
+          message: 'Viewport disables user zooming (user-scalable=no / maximum-scale=1), violating mobile accessibility guidelines.'
+        });
+      }
+
+      // 4. Check for tiny touch targets on interactive buttons without padding
+      if (/<button\b/i.test(line) && /(?:w-[1-4]\b|h-[1-4]\b)/.test(line) && !/p-[2-6]|p[xy]-[2-6]|min-h-\[44px\]|min-w-\[44px\]/.test(line)) {
+        fileViolations.push({
+          lineNo: i + 1,
+          rule: 'mobile-touch-target',
+          message: 'Interactive button has small dimensions without sufficient touch padding (minimum 44x44px recommended for mobile).'
+        });
+      }
+    }
+
+    if (fileViolations.length > 0) {
+      violations[file] = fileViolations;
+    }
+  }
+
+  const totalCount = Object.values(violations).flat().length;
+  return {
+    exitCode: totalCount > 0 ? 1 : 0,
+    skipped: false,
+    name: 'check_responsive',
+    data: {
+      violations,
+      message: totalCount > 0
+        ? `${totalCount} responsive / mobile adaptability issue(s) found in ${Object.keys(violations).length} file(s)`
+        : 'All responsive & web adaptability checks passed',
+    },
+  };
+};
+
+module.exports = check;
+
+if (require.main === module) {
+  check(process.argv[2]).then(result => {
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.exitCode);
+  });
+}