react-doctor-cli-dev 1.0.0

package/core/report-compiler/index.ts

@@ -0,0 +1,359 @@
+// ─────────────────────────────────────────────────────────────
+// report-compiler/index.ts
+//
+// The Report Compiler — the final step inside core.
+//
+// WHAT IT DOES:
+// Reads the three separate JSON files produced by the other
+// core components and merges them into one clean FinalReport.
+//
+// WHY IT EXISTS:
+// The Static Analyzer, Runtime Profiler, and Rule Engine each
+// save their own JSON files independently. The CLI needs a
+// single object to upload to the backend and show to the user.
+// This compiler does that merging so the CLI stays clean.
+//
+// INPUT FILES (all read from core/reports/):
+//   staticreport.json   — produced by the Static Analyzer
+//   runtimereport.json  — produced by the Runtime Profiler
+//   suggestions.json    — produced by the Rule Engine
+//
+// OUTPUT FILE (saved to core/reports/):
+//   finalreport.json    — the complete merged report
+//
+// FULL FLOW:
+//   1. Load all three input files from disk
+//   2. Flatten the suggestions array (Rule Engine saves one
+//      entry per route — we merge them into one deduplicated list)
+//   3. Calculate one overall performance score (average across
+//      all routes and devices)
+//   4. Assemble the FinalReport object
+//   5. Save finalreport.json
+//   6. Return the FinalReport for the CLI to use
+// ─────────────────────────────────────────────────────────────
+
+import path from "path";
+import fs   from "fs-extra";
+
+import {
+  StaticReport,
+  RuntimeReport,
+  Suggestion,
+  FinalReport,
+} from "../../shared/src/types";
+
+// ─────────────────────────────────────────────────────────────
+// INLINE TYPE: RuleEngineResult
+//
+// The Rule Engine saves suggestions.json as an array of these.
+// We define it inline here so the Report Compiler doesn't need
+// to import from the rule-engine folder — keeping dependencies
+// one-directional (compiler reads files, not code).
+// ─────────────────────────────────────────────────────────────
+interface RuleEngineResult {
+  timestamp:   string;
+  route:       string;
+  device:      string;
+  suggestions: Suggestion[];
+  summary: {
+    critical: number;
+    warning:  number;
+    info:     number;
+    total:    number;
+  };
+}
+
+export class ReportCompiler {
+
+  // All report files live in core/reports/ — one level up from
+  // this file's location at core/report-compiler/
+  private reportsDir: string;
+
+  constructor(outputDir?: string) {
+  if (outputDir) {
+    this.reportsDir = outputDir;
+  } else {
+    this.reportsDir = path.resolve(__dirname, "..", "reports");
+  }
+  fs.ensureDirSync(this.reportsDir);
+}
+
+  // ───────────────────────────────────────────────────────────
+  // PUBLIC: compile
+  // ───────────────────────────────────────────────────────────
+
+  /**
+   * Main entry point. Loads all three reports, merges them,
+   * saves finalreport.json, and returns the FinalReport object.
+   *
+   * @param projectName — display name for the project
+   *                      (used in the dashboard and backend)
+   *                      e.g. "my-react-app" or "retest"
+   *
+   * @returns The complete FinalReport ready for the CLI to upload
+   *
+   * @throws If any required report file is missing — the caller
+   *         should run the analyzer/profiler/rule-engine first.
+   */
+  /**
+   * Overloads:
+   *   compile(projectName)
+   *     — reads all three reports from disk (standalone / test use)
+   *
+   *   compile(staticReport, runtimeReports, ruleResults)
+   *     — receives data directly from the CLI pipeline in memory
+   *       (no disk read needed — faster and no stale-file issues)
+   *
+   * The CLI always passes data directly. The standalone test runner
+   * calls compile(projectName) which reads from core/reports/.
+   */
+  async compile(
+    staticReportOrName:  StaticReport | string | null,
+    runtimeReportsArg?:  Record<string, RuntimeReport>,
+    ruleResultsArg?:     any[],
+  ): Promise<FinalReport> {
+    console.log("\n📦 Report Compiler starting...");
+
+    let staticReport:   StaticReport;
+    let runtimeReports: Record<string, RuntimeReport>;
+    let ruleResults:    any[];
+    let projectName:    string;
+
+    // ── Determine call mode ────────────────────────────────────
+    if (typeof staticReportOrName === "string" || staticReportOrName === null) {
+      // Called as compile(projectName) — read from disk
+      projectName  = (staticReportOrName as string) ?? "react-app";
+      staticReport   = this.loadStaticReport();
+      runtimeReports = this.loadRuntimeReports();
+      ruleResults    = this.loadSuggestions();
+    } else {
+      // Called as compile(staticReport, runtimeReports, ruleResults)
+      // — data passed directly from the CLI pipeline
+      staticReport   = staticReportOrName;
+      runtimeReports = runtimeReportsArg ?? {};
+      ruleResults    = ruleResultsArg    ?? [];
+      // Derive project name from the runtime report URL if available
+      const firstUrl = Object.values(runtimeReports)[0]?.url ?? "";
+      projectName    = firstUrl ? new URL(firstUrl).hostname : "react-app";
+    }
+
+    // Print a quick summary of what was loaded
+    console.log(`   Static report:   ${staticReport?.issues?.length ?? 0} issue(s)`);
+    console.log(`   Runtime report:  ${Object.keys(runtimeReports).length} route+device entry(s)`);
+    console.log(`   Rule results:    ${ruleResults.length} route+device entry(s)`);
+
+    // ── Step 2: Flatten and deduplicate suggestions ────────────
+    //
+    // The Rule Engine produces one RuleEngineResult per route+device.
+    // Example: for "/::desktop" and "/::mobile" you get two results,
+    // each with their own suggestions array.
+    //
+    // The FinalReport has ONE flat suggestions array. We merge all
+    // per-route arrays together and deduplicate by suggestion ID so
+    // the same fix isn't shown twice just because it fired on both
+    // desktop and mobile.
+    const suggestions = this.mergeSuggestions(ruleResults);
+    console.log(`   Suggestions:     ${suggestions.length} (deduplicated from all routes)`);
+
+    // Log severity breakdown for quick visibility
+    const critical = suggestions.filter(s => s.severity === "critical").length;
+    const warning  = suggestions.filter(s => s.severity === "warning").length;
+    const info     = suggestions.filter(s => s.severity === "info").length;
+    if (critical > 0) console.log(`     ❌ ${critical} critical`);
+    if (warning  > 0) console.log(`     ⚠️  ${warning} warnings`);
+    if (info     > 0) console.log(`     ℹ️  ${info} info`);
+
+    // ── Step 3: Calculate one overall performance score ────────
+    //
+    // The profiler calculates a 0-100 score per route+device.
+    // Here we average them all into a single project-level score
+    // that the dashboard can display as the main health metric.
+    const performanceScore = this.calculateOverallScore(runtimeReports);
+    console.log(`   Overall score:   ${performanceScore}/100`);
+
+    // ── Step 4: Assemble the FinalReport ──────────────────────
+    const finalReport: FinalReport = {
+      projectName,
+      analyzedAt:    new Date().toISOString(),
+      static:        staticReport,
+      runtime:       runtimeReports,
+      suggestions,
+      performanceScore,
+    };
+
+    // ── Step 5: Save to disk ───────────────────────────────────
+    await this.save(finalReport);
+
+    console.log("✅ Report Compiler complete.\n");
+    return finalReport;
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // PRIVATE: loaders
+  // ───────────────────────────────────────────────────────────
+
+  /**
+   * Loads staticreport.json.
+   * Throws a clear error message if the file is missing so the
+   * developer knows exactly which command they need to run first.
+   */
+  private loadStaticReport(): StaticReport {
+    const filePath = path.join(this.reportsDir, "staticreport.json");
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(
+        `❌ staticreport.json not found at: ${filePath}\n\n` +
+        `   Run the static analyzer first:\n` +
+        `   npx ts-node --compiler-options '{"module":"commonjs"}' ` +
+        `static-ana/test-analyzer.ts`,
+      );
+    }
+
+    console.log(`   ✅ Loaded staticreport.json`);
+    return fs.readJsonSync(filePath) as StaticReport;
+  }
+
+  /**
+   * Loads runtimereport.json.
+   * The file is keyed by route+device, e.g.:
+   *   { "/::desktop": {...}, "/::mobile": {...} }
+   */
+  private loadRuntimeReports(): Record<string, RuntimeReport> {
+    const filePath = path.join(this.reportsDir, "runtimereport.json");
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(
+        `❌ runtimereport.json not found at: ${filePath}\n\n` +
+        `   Run the runtime profiler first:\n` +
+        `   npx ts-node --compiler-options '{"module":"commonjs"}' ` +
+        `runtime/test-runtime-profiler.ts <path-to-react-app>`,
+      );
+    }
+
+    console.log(`   ✅ Loaded runtimereport.json`);
+    return fs.readJsonSync(filePath) as Record<string, RuntimeReport>;
+  }
+
+  /**
+   * Loads suggestions.json.
+   * The Rule Engine saves this as an array — one RuleEngineResult
+   * per route+device combination that was analyzed.
+   */
+  private loadSuggestions(): RuleEngineResult[] {
+    const filePath = path.join(this.reportsDir, "suggestions.json");
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(
+        `❌ suggestions.json not found at: ${filePath}\n\n` +
+        `   Run the rule engine first:\n` +
+        `   npx ts-node --compiler-options '{"module":"commonjs"}' ` +
+        `rule-engine/test-rule-engine.ts`,
+      );
+    }
+
+    console.log(`   ✅ Loaded suggestions.json`);
+    return fs.readJsonSync(filePath) as RuleEngineResult[];
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // PRIVATE: mergeSuggestions
+  // ───────────────────────────────────────────────────────────
+
+  /**
+   * Flattens all per-route suggestion arrays into one flat list
+   * and removes duplicates by suggestion ID.
+   *
+   * WHY DEDUPLICATION IS NEEDED:
+   * When the profiler runs both desktop and mobile, the Rule Engine
+   * produces two RuleEngineResults for the same route — one for
+   * each device. Many rules will fire on both (e.g. "missing key
+   * props" is a static issue that applies regardless of device).
+   * Without deduplication, the final report would show the same
+   * suggestion twice.
+   *
+   * WHAT "SAME" MEANS:
+   * Two suggestions are the same if they have the same id. The id
+   * comes from the rule definition (e.g. "missing-list-keys") so
+   * it's stable across devices.
+   *
+   * WHAT WE KEEP:
+   * The first occurrence. Suggestions from the same rule are
+   * identical in title, description, and fix — only the route
+   * they came from differs, which is not part of the Suggestion
+   * interface.
+   *
+   * SORT ORDER:
+   * critical → warning → info (most important first).
+   */
+  private mergeSuggestions(ruleResults: RuleEngineResult[]): Suggestion[] {
+    const seen   = new Set<string>();
+    const merged: Suggestion[] = [];
+
+    for (const result of ruleResults) {
+      for (const suggestion of result.suggestions) {
+        // Skip if we've already added a suggestion with this id
+        if (!seen.has(suggestion.id)) {
+          seen.add(suggestion.id);
+          merged.push(suggestion);
+        }
+      }
+    }
+
+    // Sort by severity so critical issues appear first
+    const severityOrder = { critical: 0, warning: 1, info: 2 };
+    return merged.sort(
+      (a, b) =>
+        (severityOrder[a.severity] ?? 3) - (severityOrder[b.severity] ?? 3),
+    );
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // PRIVATE: calculateOverallScore
+  // ───────────────────────────────────────────────────────────
+
+  /**
+   * Averages the performanceScore from all route+device entries
+   * in the runtime report into one overall project health score.
+   *
+   * EXAMPLE:
+   *   /::desktop  → score 63
+   *   /::mobile   → score 91
+   *   overall     → Math.round((63 + 91) / 2) = 77
+   *
+   * Returns 0 if no runtime data exists (static-only run).
+   */
+  private calculateOverallScore(
+    runtimeReports: Record<string, RuntimeReport>,
+  ): number {
+    const entries = Object.values(runtimeReports);
+    if (entries.length === 0) return 0;
+
+    const total = entries.reduce(
+      (sum, report) => sum + (report.performanceScore ?? 0),
+      0,
+    );
+
+    return Math.round(total / entries.length);
+  }
+
+  // ───────────────────────────────────────────────────────────
+  // PRIVATE: save
+  // ───────────────────────────────────────────────────────────
+
+  /**
+   * Saves the FinalReport to core/reports/finalreport.json.
+   *
+   * NOTE ON FILE SIZE:
+   * The runtime report embeds screenshot data URLs (base64-encoded
+   * PNGs) which can make this file large — typically 2-5MB per
+   * screenshot. The PNG files already exist in core/reports/screenshots/
+   * so the CLI can strip the base64 data URLs before uploading to
+   * the backend if bandwidth is a concern.
+   */
+  private async save(report: FinalReport): Promise<void> {
+  fs.ensureDirSync(this.reportsDir);
+  const outputPath = path.join(this.reportsDir, "finalreport.json");
+  await fs.writeJson(outputPath, report, { spaces: 2 });
+  console.log(`📄 Final report saved to: ${outputPath}`);
+}
+}

package/core/report-compiler/test-report-compiler.ts

@@ -0,0 +1,126 @@
+// ─────────────────────────────────────────────────────────────
+// report-compiler/test-report-compiler.ts
+//
+// Test runner for the Report Compiler.
+// Reads the existing three report files from core/reports/
+// and compiles them into finalreport.json.
+//
+// PREREQUISITES — run these first (from the core/ directory):
+//   npx ts-node --compiler-options '{"module":"commonjs"}' static-ana/test-analyzer.ts
+//   npx ts-node --compiler-options '{"module":"commonjs"}' runtime/test-runtime-profiler.ts <path>
+//   npx ts-node --compiler-options '{"module":"commonjs"}' rule-engine/test-rule-engine.ts
+//
+// THEN run this (from the core/ directory):
+//   npx ts-node --compiler-options '{"module":"commonjs"}' report-compiler/test-report-compiler.ts
+// ─────────────────────────────────────────────────────────────
+
+import { ReportCompiler } from "./index";
+import { FinalReport }    from "../../shared/src/types";
+import path               from "path";
+
+// ── Helpers ───────────────────────────────────────────────────
+
+function scoreBadge(score: number): string {
+  if (score >= 90) return `${score}/100 🟢 Excellent`;
+  if (score >= 70) return `${score}/100 🟡 Good`;
+  if (score >= 50) return `${score}/100 🟠 Needs Work`;
+  return `${score}/100 🔴 Poor`;
+}
+
+function printSummary(report: FinalReport): void {
+  console.log("=".repeat(60));
+  console.log(`📋  FINAL REPORT SUMMARY`);
+  console.log("=".repeat(60));
+
+  console.log(`\n  Project:    ${report.projectName}`);
+  console.log(`  Analyzed:   ${new Date(report.analyzedAt).toLocaleString()}`);
+  console.log(`  Score:      ${scoreBadge(report.performanceScore)}`);
+
+  // Static summary
+  console.log(`\n  📂 Static Analysis`);
+  console.log(`     Files analyzed:  ${report.static.filesAnalyzed}`);
+  console.log(`     Issues found:    ${report.static.issues.length}`);
+  console.log(`     Grade:           ${report.static.grade}`);
+
+  const critical = report.static.issues.filter(i => i.severity === "critical").length;
+  const warnings = report.static.issues.filter(i => i.severity === "warning").length;
+  const infos    = report.static.issues.filter(i => i.severity === "info").length;
+  if (critical > 0) console.log(`       ❌ ${critical} critical`);
+  if (warnings > 0) console.log(`       ⚠️  ${warnings} warnings`);
+  if (infos    > 0) console.log(`       ℹ️  ${infos} info`);
+
+  // Runtime summary — one line per route+device
+  console.log(`\n  ⚡ Runtime Profiling`);
+  for (const [key, entry] of Object.entries(report.runtime)) {
+    const [route, device] = key.includes("::") ? key.split("::") : [key, "desktop"];
+    const score = entry.performanceScore ?? 0;
+    const dot   = score >= 90 ? "🟢" : score >= 70 ? "🟡" : score >= 50 ? "🟠" : "🔴";
+    console.log(`     ${dot} ${route} [${device}]  ${score}/100  — LCP: ${entry.metrics.lcp.toFixed(0)}ms  Render: ${entry.renderTime}ms`);
+  }
+
+  // Suggestions summary
+  console.log(`\n  🧠 Suggestions (${report.suggestions.length} total)`);
+  const critSug = report.suggestions.filter(s => s.severity === "critical");
+  const warnSug = report.suggestions.filter(s => s.severity === "warning");
+  const infoSug = report.suggestions.filter(s => s.severity === "info");
+
+  if (critSug.length > 0) {
+    console.log(`\n  ❌ Critical (${critSug.length}):`);
+    critSug.forEach(s => {
+      const comp = s.affectedComponent ? ` [${s.affectedComponent}]` : "";
+      console.log(`     • ${s.title}${comp}`);
+    });
+  }
+
+  if (warnSug.length > 0) {
+    console.log(`\n  ⚠️  Warnings (${warnSug.length}):`);
+    warnSug.forEach(s => {
+      const comp = s.affectedComponent ? ` [${s.affectedComponent}]` : "";
+      console.log(`     • ${s.title}${comp}`);
+    });
+  }
+
+  if (infoSug.length > 0) {
+    console.log(`\n  ℹ️  Info (${infoSug.length}):`);
+    infoSug.forEach(s => {
+      const comp = s.affectedComponent ? ` [${s.affectedComponent}]` : "";
+      console.log(`     • ${s.title}${comp}`);
+    });
+  }
+
+  console.log("\n" + "=".repeat(60));
+}
+
+// ── Main ──────────────────────────────────────────────────────
+
+async function main() {
+  console.log("=========================================================");
+  console.log("📦  REACT DOCTOR — REPORT COMPILER");
+  console.log("=========================================================");
+
+  // The project name is taken from the command line argument,
+  // or defaults to "react-app" if none is provided.
+  // Usage: npx ts-node ... test-report-compiler.ts my-project-name
+  const projectName = process.argv[2] ?? "react-app";
+
+  const compiler = new ReportCompiler();
+
+  try {
+    const finalReport = await compiler.compile(projectName);
+    printSummary(finalReport);
+
+    console.log("✅ Done. finalreport.json is ready for the backend.");
+    console.log("=========================================================\n");
+
+  } catch (err: unknown) {
+    console.error("\n❌ Report Compiler error:");
+    console.error((err as Error).message);
+    console.error("\nMake sure you have run all three steps first:");
+    console.error("  1. static-ana/test-analyzer.ts");
+    console.error("  2. runtime/test-runtime-profiler.ts <path>");
+    console.error("  3. rule-engine/test-rule-engine.ts\n");
+    process.exit(1);
+  }
+}
+
+main();

package/core/rule-engine/context-builder.ts

@@ -0,0 +1,146 @@
+// Builds the EvaluationContext object from the static and
+// runtime reports. This is the "scope" that rule conditions
+// run inside — every field a condition can access lives here.
+//
+// WHY THIS FILE EXISTS:
+// The reports store data in their own formats (strings for MB
+// values, arrays for commits, etc). The EvaluationContext
+// normalises everything into clean, easy-to-use values so
+// condition expressions like "payloadMB > 3" just work without
+// needing to call parseFloat() or .length inside the rule itself.
+// ─────────────────────────────────────────────────────────────
+
+import { StaticReport, RuntimeReport } from "../../shared/src/types";
+import { EvaluationContext } from "./types";
+
+/**
+ * Assembles a flat EvaluationContext from the static and
+ * runtime reports.
+ *
+ * Both parameters are optional because:
+ *   - A "static-only" rule only needs the static report
+ *   - A "runtime-only" rule only needs the runtime report
+ *   - A "cross" rule needs both
+ *
+ * If a report is missing, its corresponding fields are set
+ * to safe zero/empty defaults so conditions that check them
+ * simply evaluate to false instead of throwing an error.
+ *
+ * @param staticReport  — result of the Static Analyzer (or null)
+ * @param runtimeReport — result of the Runtime Profiler  (or null)
+ */
+export function buildContext(
+  staticReport:  StaticReport  | null,
+  runtimeReport: RuntimeReport | null,
+): EvaluationContext {
+
+  // ── Runtime fields ──────────────────────────────────────────
+  // Pull every value we need from the runtime report.
+  // Default to 0 / empty if the runtime report wasn't provided.
+
+  const metrics = runtimeReport?.metrics ?? {
+    lcp: 0, fcp: 0, cls: 0, inp: 0, ttfb: 0,
+  };
+
+  const renderTime       = runtimeReport?.renderTime       ?? 0;
+  const rerenders        = runtimeReport?.rerenders        ?? {};
+  const commitDurations  = runtimeReport?.commitDurations  ?? [];
+  const domNodes         = runtimeReport?.stats?.domNodes  ?? 0;
+  const performanceScore = runtimeReport?.performanceScore ?? 0;
+  const errors           = runtimeReport?.errors           ?? [];
+
+  // payloadMB and jsHeapMB are stored as strings ("1.49") in the
+  // report for display purposes. Convert them to numbers here so
+  // conditions can compare them with > < operators directly.
+  const payloadMB = parseFloat(runtimeReport?.stats?.payloadMB ?? "0");
+  const jsHeapMB  = parseFloat(runtimeReport?.stats?.jsHeapMB  ?? "0");
+
+  // ── Derived runtime values ──────────────────────────────────
+  // These are calculated from the raw data above for convenience.
+  // Putting the math here keeps the rule condition strings clean.
+
+  // Slowest single commit — 0 if no commits were recorded
+  const slowestCommit = commitDurations.length > 0
+    ? Math.max(...commitDurations)
+    : 0;
+
+  // Average commit duration — 0 if no commits were recorded
+  const avgCommit = commitDurations.length > 0
+    ? commitDurations.reduce((a, b) => a + b, 0) / commitDurations.length
+    : 0;
+
+  // How many commits exceeded the 16ms 60fps frame budget
+  // Any commit over 16ms causes a visible dropped frame
+  const slowCommitCount = commitDurations.filter(d => d > 16).length;
+
+  // Error/warning counts — shorthand so rules don't need to
+  // write errors.filter(e => e.type === 'error').length every time
+  const errorCount   = errors.filter(e => e.type === "error").length;
+  const warningCount = errors.filter(e => e.type === "warning").length;
+
+  // Find the component with the most re-renders — this is the
+  // primary suspect when the "excessive rerenders" rule fires.
+  // Returns ["ComponentName", count] or ["", 0] if no data.
+  const rerenderEntries = Object.entries(rerenders);
+  const [topRerenderComponent, topRerenderCount] =
+    rerenderEntries.length > 0
+      ? rerenderEntries.reduce(
+          (max, entry) => (entry[1] > max[1] ? entry : max),
+          ["", 0] as [string, number],
+        )
+      : ["", 0];
+
+  // ── Static fields ────────────────────────────────────────────
+  // Pull the issues array from the static report.
+  // Default to empty array if the static report wasn't provided.
+
+  const issues = staticReport?.issues ?? [];
+
+  const criticalIssueCount = issues.filter(i => i.severity === "critical").length;
+  const warningIssueCount  = issues.filter(i => i.severity === "warning").length;
+
+  // hasIssue(prefix) — returns true if any issue ID starts with
+  // the given prefix. Used in conditions like: hasIssue('missing-memo')
+  //
+  // The issue IDs are generated by the detectors like this:
+  //   generateIssueId('missing-memo', filePath, line)
+  //   → "missing-memo-src/components/Button.tsx-42"
+  //
+  // So checking startsWith('missing-memo') catches all of them
+  // regardless of which file or line they came from.
+  const hasIssue = (prefix: string): boolean =>
+    issues.some(i => i.id.startsWith(prefix));
+
+  // getIssues(prefix) — returns all matching issue objects.
+  // Used when a condition or message needs the actual issue data.
+  const getIssues = (prefix: string) =>
+    issues.filter(i => i.id.startsWith(prefix));
+
+  // ── Assemble the full context ─────────────────────────────
+  return {
+    // Runtime
+    metrics,
+    renderTime,
+    rerenders,
+    commitDurations,
+    slowestCommit,
+    avgCommit,
+    slowCommitCount,
+    domNodes,
+    payloadMB,
+    jsHeapMB,
+    errors,
+    errorCount,
+    warningCount,
+    performanceScore,
+    topRerenderComponent,
+    topRerenderCount,
+
+    // Static
+    issues,
+    criticalIssueCount,
+    warningIssueCount,
+    hasIssue,
+    getIssues,
+  };
+}