chainlesschain 0.47.9 → 0.51.0

package/src/commands/recommend.js

@@ -0,0 +1,336 @@
+/**
+ * `cc recommend` — CLI surface for Phase 48 Smart Content Recommendation.
+ */
+
+import { Command } from "commander";
+
+import {
+  CONTENT_TYPES,
+  RECOMMENDATION_STATUS,
+  FEEDBACK_VALUES,
+  DEFAULT_CONFIG,
+  ensureRecommendationTables,
+  getProfile,
+  createProfile,
+  updateProfile,
+  deleteProfile,
+  listProfiles,
+  applyDecay,
+  scoreContent,
+  generateRecommendations,
+  getRecommendation,
+  listRecommendations,
+  markViewed,
+  provideFeedback,
+  dismissRecommendation,
+  getRecommendationStats,
+  getTopInterests,
+  suggestTopics,
+} from "../lib/content-recommendation.js";
+
+function _dbFromCtx(cmd) {
+  const root = cmd?.parent?.parent ?? cmd?.parent;
+  return root?._db;
+}
+
+export function registerRecommendCommand(program) {
+  const rec = new Command("recommend")
+    .description("Smart content recommendation (Phase 48)")
+    .hook("preAction", (thisCmd) => {
+      const db = _dbFromCtx(thisCmd);
+      if (db) ensureRecommendationTables(db);
+    });
+
+  /* ── Catalogs ────────────────────────────────────── */
+
+  rec
+    .command("content-types")
+    .description("List supported content types")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const types = Object.values(CONTENT_TYPES);
+      if (opts.json) return console.log(JSON.stringify(types, null, 2));
+      for (const t of types)
+        console.log(`  ${t.id.padEnd(12)} ${t.name} — ${t.description}`);
+    });
+
+  rec
+    .command("statuses")
+    .description("List recommendation statuses")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const statuses = Object.values(RECOMMENDATION_STATUS);
+      if (opts.json) return console.log(JSON.stringify(statuses, null, 2));
+      for (const s of statuses) console.log(`  ${s}`);
+    });
+
+  rec
+    .command("feedback-values")
+    .description("List feedback values")
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const vals = Object.values(FEEDBACK_VALUES);
+      if (opts.json) return console.log(JSON.stringify(vals, null, 2));
+      for (const v of vals) console.log(`  ${v}`);
+    });
+
+  /* ── Profile Management ──────────────────────────── */
+
+  rec
+    .command("profile <user-id>")
+    .description("Show user interest profile")
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const p = getProfile(db, userId);
+      if (!p) return console.log("Profile not found.");
+      if (opts.json) return console.log(JSON.stringify(p, null, 2));
+      console.log(`User:     ${p.user_id}`);
+      console.log(`Updated:  ${new Date(p.last_updated).toISOString()}`);
+      console.log(`Updates:  ${p.update_count}`);
+      console.log(`Decay:    ${p.decay_factor}`);
+      console.log(`Topics:`);
+      for (const [t, w] of Object.entries(p.topics))
+        console.log(`  ${t}: ${w}`);
+    });
+
+  rec
+    .command("create-profile <user-id>")
+    .description("Create interest profile for a user")
+    .option("-t, --topics <json>", "Topic weights JSON")
+    .option("-w, --weights <json>", "Interaction weights JSON")
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const topics = opts.topics ? JSON.parse(opts.topics) : {};
+      const interactionWeights = opts.weights ? JSON.parse(opts.weights) : {};
+      const result = createProfile(db, userId, { topics, interactionWeights });
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      if (result.profileId) console.log(`Profile created: ${result.profileId}`);
+      else console.log(`Failed: ${result.reason}`);
+    });
+
+  rec
+    .command("update-profile <user-id>")
+    .description("Update interest profile")
+    .option("-t, --topics <json>", "Topic weights JSON")
+    .option("-w, --weights <json>", "Interaction weights JSON")
+    .option("-d, --decay <factor>", "Decay factor", parseFloat)
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const params = {};
+      if (opts.topics) params.topics = JSON.parse(opts.topics);
+      if (opts.weights) params.interactionWeights = JSON.parse(opts.weights);
+      if (opts.decay !== undefined) params.decayFactor = opts.decay;
+      const result = updateProfile(db, userId, params);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.updated ? "Profile updated." : `Failed: ${result.reason}`,
+      );
+    });
+
+  rec
+    .command("delete-profile <user-id>")
+    .description("Delete interest profile")
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const result = deleteProfile(db, userId);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.deleted ? "Profile deleted." : `Failed: ${result.reason}`,
+      );
+    });
+
+  rec
+    .command("profiles")
+    .description("List all interest profiles")
+    .option("--limit <n>", "Max results", parseInt)
+    .option("--json", "JSON output")
+    .action((opts) => {
+      const db = _dbFromCtx(rec);
+      const profiles = listProfiles(db, { limit: opts.limit });
+      if (opts.json) return console.log(JSON.stringify(profiles, null, 2));
+      if (profiles.length === 0) return console.log("No profiles.");
+      for (const p of profiles) {
+        const topicCount = Object.keys(p.topics).length;
+        console.log(
+          `  ${p.user_id.padEnd(20)} ${topicCount} topics  updated ${new Date(p.last_updated).toISOString()}`,
+        );
+      }
+    });
+
+  rec
+    .command("decay <user-id>")
+    .description("Apply time decay to profile topics")
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const result = applyDecay(db, userId);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      if (result.applied)
+        console.log(`Decay applied. ${result.topicCount} topics remaining.`);
+      else console.log(`Failed: ${result.reason}`);
+    });
+
+  /* ── Recommendation Generation ───────────────────── */
+
+  rec
+    .command("generate <user-id>")
+    .description(
+      "Generate recommendations from content pool (JSON stdin or --pool)",
+    )
+    .option("-p, --pool <json>", "Content pool as JSON array")
+    .option("-l, --limit <n>", "Max recommendations", parseInt)
+    .option("-m, --min-score <n>", "Minimum score", parseFloat)
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      if (!opts.pool) {
+        return console.log("Provide --pool as JSON array of content items.");
+      }
+      const pool = JSON.parse(opts.pool);
+      const result = generateRecommendations(db, userId, pool, {
+        limit: opts.limit,
+        minScore: opts.minScore,
+      });
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      if (result.reason) return console.log(`Failed: ${result.reason}`);
+      console.log(`Generated ${result.generated} recommendations.`);
+    });
+
+  /* ── Recommendation CRUD ─────────────────────────── */
+
+  rec
+    .command("show <rec-id>")
+    .description("Show recommendation details")
+    .option("--json", "JSON output")
+    .action((recId, opts) => {
+      const db = _dbFromCtx(rec);
+      const r = getRecommendation(db, recId);
+      if (!r) return console.log("Recommendation not found.");
+      if (opts.json) return console.log(JSON.stringify(r, null, 2));
+      console.log(`ID:       ${r.id}`);
+      console.log(`User:     ${r.user_id}`);
+      console.log(`Content:  ${r.content_id} (${r.content_type})`);
+      console.log(`Title:    ${r.title}`);
+      console.log(`Score:    ${r.score}`);
+      console.log(`Reason:   ${r.reason}`);
+      console.log(`Status:   ${r.status}`);
+      if (r.feedback) console.log(`Feedback: ${r.feedback}`);
+    });
+
+  rec
+    .command("list <user-id>")
+    .description("List recommendations for a user")
+    .option("-s, --status <status>", "Filter by status")
+    .option("-t, --type <type>", "Filter by content type")
+    .option("-m, --min-score <n>", "Minimum score", parseFloat)
+    .option("--limit <n>", "Max results", parseInt)
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const recs = listRecommendations(db, userId, {
+        status: opts.status,
+        contentType: opts.type,
+        limit: opts.limit,
+        minScore: opts.minScore,
+      });
+      if (opts.json) return console.log(JSON.stringify(recs, null, 2));
+      if (recs.length === 0) return console.log("No recommendations.");
+      for (const r of recs) {
+        const fb = r.feedback ? ` [${r.feedback}]` : "";
+        console.log(
+          `  ${r.score.toFixed(3)}  ${r.status.padEnd(10)} ${r.title || r.content_id}${fb}`,
+        );
+      }
+    });
+
+  rec
+    .command("view <rec-id>")
+    .description("Mark recommendation as viewed")
+    .option("--json", "JSON output")
+    .action((recId, opts) => {
+      const db = _dbFromCtx(rec);
+      const result = markViewed(db, recId);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.marked ? "Marked as viewed." : `Failed: ${result.reason}`,
+      );
+    });
+
+  rec
+    .command("feedback <rec-id> <value>")
+    .description("Provide feedback (like / dislike / later)")
+    .option("--json", "JSON output")
+    .action((recId, value, opts) => {
+      const db = _dbFromCtx(rec);
+      const result = provideFeedback(db, recId, value);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(
+        result.recorded ? "Feedback recorded." : `Failed: ${result.reason}`,
+      );
+    });
+
+  rec
+    .command("dismiss <rec-id>")
+    .description("Dismiss a recommendation")
+    .option("--json", "JSON output")
+    .action((recId, opts) => {
+      const db = _dbFromCtx(rec);
+      const result = dismissRecommendation(db, recId);
+      if (opts.json) return console.log(JSON.stringify(result, null, 2));
+      console.log(result.dismissed ? "Dismissed." : `Failed: ${result.reason}`);
+    });
+
+  /* ── Stats & Insights ────────────────────────────── */
+
+  rec
+    .command("stats <user-id>")
+    .description("Recommendation statistics")
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const stats = getRecommendationStats(db, userId);
+      if (opts.json) return console.log(JSON.stringify(stats, null, 2));
+      console.log(`Total:         ${stats.total}`);
+      console.log(`Pending:       ${stats.pending}`);
+      console.log(`Viewed:        ${stats.viewed}`);
+      console.log(`Dismissed:     ${stats.dismissed}`);
+      console.log(
+        `Feedback:      ${stats.feedbackCount} (${(stats.feedbackRate * 100).toFixed(1)}%)`,
+      );
+      console.log(`Avg score:     ${stats.avgScore}`);
+    });
+
+  rec
+    .command("top-interests <user-id>")
+    .description("Show top interests from profile")
+    .option("--limit <n>", "Max results", parseInt)
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const interests = getTopInterests(db, userId, { limit: opts.limit });
+      if (opts.json) return console.log(JSON.stringify(interests, null, 2));
+      if (interests.length === 0) return console.log("No interests found.");
+      for (const i of interests)
+        console.log(`  ${i.topic.padEnd(20)} ${i.weight}`);
+    });
+
+  rec
+    .command("suggest <user-id>")
+    .description("Suggest profile adjustments from feedback patterns")
+    .option("--json", "JSON output")
+    .action((userId, opts) => {
+      const db = _dbFromCtx(rec);
+      const suggestions = suggestTopics(db, userId);
+      if (opts.json) return console.log(JSON.stringify(suggestions, null, 2));
+      if (suggestions.length === 0)
+        return console.log("No suggestions — need more feedback.");
+      for (const s of suggestions)
+        console.log(`  ${s.action.padEnd(8)} ${s.topic} by ${s.amount}`);
+    });
+
+  program.addCommand(rec);
+}

package/src/commands/reputation.js

@@ -0,0 +1,349 @@
+/**
+ * Reputation commands
+ * chainlesschain reputation observe|score|list|decay-preview|anomalies|optimize|status|analytics|apply
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureReputationTables,
+  addObservation,
+  computeScore,
+  listScores,
+  detectAnomalies,
+  startOptimization,
+  getOptimizationStatus,
+  getAnalytics,
+  listOptimizationRuns,
+  applyOptimizedParams,
+  OPTIMIZATION_OBJECTIVES,
+} from "../lib/reputation-optimizer.js";
+
+function _dbFromCtx(ctx) {
+  if (!ctx.db) {
+    logger.error("Database not available");
+    process.exit(1);
+  }
+  const db = ctx.db.getDatabase();
+  ensureReputationTables(db);
+  return db;
+}
+
+export function registerReputationCommand(program) {
+  const rep = program
+    .command("reputation")
+    .alias("rep")
+    .description(
+      "Reputation optimizer — observations, decay, anomaly detection, Bayesian optimization",
+    );
+
+  rep
+    .command("observe <did> <score>")
+    .description("Record a reputation observation (score in [0,1])")
+    .option(
+      "-k, --kind <kind>",
+      "Observation kind (generic|task|review|vote)",
+      "generic",
+    )
+    .option("-w, --weight <n>", "Observation weight", parseFloat, 1)
+    .option("--json", "Output as JSON")
+    .action(async (did, score, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const obs = addObservation(db, did, Number(score), {
+          kind: options.kind,
+          weight: options.weight,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(obs, null, 2));
+        } else {
+          logger.success(`Observation recorded`);
+          logger.log(`  ${chalk.bold("DID:")}    ${chalk.cyan(obs.did)}`);
+          logger.log(`  ${chalk.bold("Score:")}  ${obs.score}`);
+          logger.log(`  ${chalk.bold("Kind:")}   ${obs.kind}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("score <did>")
+    .description("Compute aggregated reputation score for a DID")
+    .option(
+      "-d, --decay <model>",
+      "Decay model (none|exponential|linear|step)",
+      "none",
+    )
+    .option("--lambda <n>", "Exponential decay lambda", parseFloat)
+    .option("--alpha <n>", "Linear decay alpha", parseFloat)
+    .option("--json", "Output as JSON")
+    .action(async (did, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const result = computeScore(did, {
+          decay: options.decay,
+          lambda: options.lambda,
+          alpha: options.alpha,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.bold("DID:")}          ${chalk.cyan(result.did)}`,
+          );
+          logger.log(`  ${chalk.bold("Score:")}        ${result.score}`);
+          logger.log(`  ${chalk.bold("Observations:")} ${result.observations}`);
+          logger.log(`  ${chalk.bold("Decay:")}        ${result.decay}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("list")
+    .description("List all tracked DIDs with computed scores")
+    .option("-d, --decay <model>", "Decay model", "none")
+    .option("--limit <n>", "Maximum entries", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = listScores({
+          decay: options.decay,
+          limit: options.limit,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No reputation data recorded.");
+        } else {
+          for (const r of rows) {
+            logger.log(
+              `  ${chalk.cyan(r.did.slice(0, 24).padEnd(24))} score=${r.score} obs=${r.observations}`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("anomalies")
+    .description("Detect anomalies in current reputation scores")
+    .option(
+      "-m, --method <method>",
+      "Detection method (z_score|iqr)",
+      "z_score",
+    )
+    .option("-t, --threshold <n>", "Detection threshold", parseFloat)
+    .option(
+      "-d, --decay <model>",
+      "Decay model applied before detection",
+      "none",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const result = detectAnomalies({
+          method: options.method,
+          threshold: options.threshold,
+          decay: options.decay,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Method:")}   ${result.method}`);
+          logger.log(`  ${chalk.bold("Samples:")}  ${result.totalSamples}`);
+          if (result.message) {
+            logger.info(`  ${result.message}`);
+          } else {
+            logger.log(`  ${chalk.bold("Summary:")}  ${result.summary}`);
+            for (const a of result.anomalies) {
+              logger.log(
+                `    ${chalk.yellow(a.did.slice(0, 24))} score=${a.score} ${a.reason}`,
+              );
+            }
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("optimize")
+    .description("Run parameter optimization over the reputation algorithm")
+    .option(
+      "-o, --objective <name>",
+      "Objective (accuracy|fairness|resilience|convergence_speed)",
+      "accuracy",
+    )
+    .option("-i, --iterations <n>", "Iteration count", parseInt, 50)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const db = _dbFromCtx(ctx);
+        const run = startOptimization(db, {
+          objective: options.objective,
+          iterations: options.iterations,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(run, null, 2));
+        } else {
+          logger.success(`Optimization ${run.status}`);
+          logger.log(
+            `  ${chalk.bold("Run ID:")}      ${chalk.cyan(run.runId)}`,
+          );
+          logger.log(`  ${chalk.bold("Objective:")}   ${run.objective}`);
+          logger.log(`  ${chalk.bold("Iterations:")}  ${run.iterations}`);
+          logger.log(`  ${chalk.bold("Best score:")}  ${run.bestScore}`);
+          logger.log(
+            `  ${chalk.bold("Best params:")} ${JSON.stringify(run.bestParams)}`,
+          );
+          for (const rec of run.analytics.recommendations) {
+            logger.log(`    ${chalk.green("→")} ${rec}`);
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("status <run-id>")
+    .description("Show optimization run status")
+    .option("--json", "Output as JSON")
+    .action(async (runId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const run = getOptimizationStatus(runId);
+        if (options.json) {
+          console.log(JSON.stringify(run, null, 2));
+        } else {
+          logger.log(
+            `  ${chalk.bold("Run ID:")}      ${chalk.cyan(run.runId)}`,
+          );
+          logger.log(`  ${chalk.bold("Status:")}      ${run.status}`);
+          logger.log(`  ${chalk.bold("Objective:")}   ${run.objective}`);
+          logger.log(`  ${chalk.bold("Best score:")}  ${run.bestScore}`);
+          logger.log(
+            `  ${chalk.bold("Best params:")} ${JSON.stringify(run.bestParams)}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("analytics <run-id>")
+    .description("Show analytics for an optimization run")
+    .option("--json", "Output as JSON")
+    .action(async (runId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const a = getAnalytics(runId);
+        if (options.json) {
+          console.log(JSON.stringify(a, null, 2));
+        } else {
+          logger.log(`  ${chalk.bold("Run ID:")} ${chalk.cyan(a.runId)}`);
+          logger.log(`  ${chalk.bold("Distribution:")}`);
+          for (const b of a.reputationDistribution.buckets) {
+            logger.log(`    ${b.label.padEnd(15)} ${b.count}`);
+          }
+          logger.log(
+            `  ${chalk.bold("Anomalies:")} ${a.anomalies.summary || a.anomalies.message || ""}`,
+          );
+          for (const r of a.recommendations) {
+            logger.log(`    ${chalk.green("→")} ${r}`);
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("runs")
+    .description("List optimization run history")
+    .option("--limit <n>", "Maximum entries", parseInt, 10)
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const rows = listOptimizationRuns({ limit: options.limit });
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+        } else if (rows.length === 0) {
+          logger.info("No optimization runs recorded.");
+        } else {
+          for (const r of rows) {
+            logger.log(
+              `  ${chalk.cyan(r.runId.slice(0, 8))} ${r.objective.padEnd(20)} iters=${r.iterations} best=${r.bestScore} [${r.status}]`,
+            );
+          }
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("apply <run-id>")
+    .description("Mark an optimization run as applied")
+    .action(async (runId) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        _dbFromCtx(ctx);
+        const r = applyOptimizedParams(runId);
+        logger.success(`Applied run ${runId.slice(0, 8)}`);
+        logger.log(`  ${chalk.bold("Params:")} ${JSON.stringify(r.params)}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  rep
+    .command("objectives")
+    .description("List supported optimization objectives")
+    .option("--json", "Output as JSON")
+    .action((options) => {
+      const values = Object.values(OPTIMIZATION_OBJECTIVES);
+      if (options.json) {
+        console.log(JSON.stringify(values, null, 2));
+      } else {
+        for (const v of values) logger.log(`  ${chalk.cyan(v)}`);
+      }
+    });
+}