oh-my-llmwikimode 1.0.0

package/src/wiki/alias-suggestions.js

@@ -0,0 +1,180 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+
+/**
+ * B2 Alias Suggestions — Review-Only Artifacts
+ *
+ * Generates JSON artifacts under .system/search-feedback/suggestions/
+ * from zero-result search feedback events.
+ */
+
+export const ALIAS_SUGGESTION_VERSION = 1;
+export const SUGGESTIONS_DIR = ".system/search-feedback/suggestions";
+
+function getSuggestionsDir(wikiRoot) {
+  return path.join(wikiRoot, SUGGESTIONS_DIR);
+}
+
+function ensureSuggestionsDir(wikiRoot) {
+  const dir = getSuggestionsDir(wikiRoot);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function shortHash(value) {
+  return crypto.createHash("sha256").update(String(value)).digest("hex").slice(0, 12);
+}
+
+function generateSuggestionId(queryHash, timestamp) {
+  return `alias_${shortHash(queryHash + timestamp)}`;
+}
+
+function generateSuggestionFilename(queryHash, timestamp) {
+  // Format: YYYYMMDDTHHmmssZ (ISO 8601 basic format, no separators)
+  const d = new Date(timestamp);
+  const year = d.getUTCFullYear();
+  const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(d.getUTCDate()).padStart(2, "0");
+  const hours = String(d.getUTCHours()).padStart(2, "0");
+  const minutes = String(d.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(d.getUTCSeconds()).padStart(2, "0");
+  const ts = `${year}${month}${day}T${hours}${minutes}${seconds}Z`;
+  return `${ts}-${shortHash(queryHash)}.json`;
+}
+
+/**
+ * Check if a proposed alias already exists in the current index.
+ *
+ * @param {string} proposedAlias
+ * @param {Object} index - Build index from store.js
+ * @returns {boolean}
+ */
+function aliasExists(proposedAlias, index) {
+  if (!proposedAlias || !index || !Array.isArray(index.entries)) {
+    return false;
+  }
+
+  const normalized = proposedAlias.toLowerCase().trim();
+  if (!normalized) return false;
+
+  for (const entry of index.entries) {
+    const title = String(entry.title || "").toLowerCase().trim();
+    if (title === normalized) return true;
+
+    const aliases = Array.isArray(entry.aliases) ? entry.aliases : [];
+    for (const alias of aliases) {
+      if (String(alias).toLowerCase().trim() === normalized) return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Generate a review-only alias suggestion artifact from a search failure event.
+ *
+ * @param {string} wikiRoot
+ * @param {Object} failureEvent - A search failure event record
+ * @param {Object} [index] - Current wiki index (for duplicate detection)
+ * @param {Object} [options]
+ * @param {Date|string} [options.now] - Injected timestamp
+ * @returns {{success: boolean, artifact?: Object, skipped?: boolean, reason?: string, error?: string}}
+ */
+export function generateAliasSuggestion(wikiRoot, failureEvent, index, options = {}) {
+  try {
+    if (!failureEvent || typeof failureEvent !== "object") {
+      return { success: false, error: "Invalid failure event" };
+    }
+
+    const proposedAlias = String(failureEvent.query || "").trim();
+    if (!proposedAlias) {
+      return { success: false, error: "failure event has no query" };
+    }
+
+    // Skip if alias already exists
+    if (index && aliasExists(proposedAlias, index)) {
+      return {
+        success: true,
+        skipped: true,
+        reason: "Alias already exists in index",
+      };
+    }
+
+    const now = options.now ? new Date(options.now) : new Date();
+    const ts = now.toISOString();
+    const queryHash = failureEvent.query_hash || "";
+
+    const artifact = {
+      version: ALIAS_SUGGESTION_VERSION,
+      id: generateSuggestionId(queryHash, ts),
+      status: "review_required",
+      action: "consider_alias",
+      proposed_alias: proposedAlias,
+      target_path: Array.isArray(failureEvent.top_paths) && failureEvent.top_paths.length > 0
+        ? failureEvent.top_paths[0]
+        : null,
+      evidence: {
+        failure_id: failureEvent.id || null,
+        query_hash: queryHash,
+      },
+      auto_apply: false,
+      created_at: ts,
+    };
+
+    // Write artifact
+    ensureSuggestionsDir(wikiRoot);
+    const filename = generateSuggestionFilename(queryHash, ts);
+    const filePath = path.join(getSuggestionsDir(wikiRoot), filename);
+    fs.writeFileSync(filePath, JSON.stringify(artifact, null, 2), "utf-8");
+
+    return { success: true, artifact, path: filePath };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * List all alias suggestion artifacts.
+ *
+ * @param {string} wikiRoot
+ * @returns {{success: boolean, suggestions?: Array, error?: string}}
+ */
+export function listAliasSuggestions(wikiRoot) {
+  try {
+    const dir = getSuggestionsDir(wikiRoot);
+    if (!fs.existsSync(dir)) {
+      return { success: true, suggestions: [] };
+    }
+
+    const files = fs
+      .readdirSync(dir)
+      .filter((f) => f.endsWith(".json"))
+      .sort();
+
+    const suggestions = [];
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(dir, file), "utf-8");
+        suggestions.push(JSON.parse(content));
+      } catch {
+        // Skip malformed files
+      }
+    }
+
+    return { success: true, suggestions };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Count alias suggestion artifacts.
+ *
+ * @param {string} wikiRoot
+ * @returns {number}
+ */
+export function countAliasSuggestions(wikiRoot) {
+  const result = listAliasSuggestions(wikiRoot);
+  return result.success ? result.suggestions.length : 0;
+}

package/src/wiki/browser-data.js

@@ -0,0 +1,284 @@
+import fs from "node:fs";
+import path from "node:path";
+import { redactSecrets } from "../security.js";
+import { buildCuratorBrowserData } from "../curator/browser-data.js";
+import { buildAgentTeamBrowserData } from "../team/browser-data.js";
+import { buildTodoBrowserData } from "../todo/browser-data.js";
+import { buildGraphReasoningBrowserData } from "../stage4/graph-reasoning/browser-data.js";
+import {
+  detectDuplicates,
+  ensureWikiStructure,
+  getWikiPaths,
+  parseFrontmatter,
+} from "./store.js";
+
+export const BROWSER_DATA_RELATIVE_PATH = ".system/browser-data.json";
+
+const AUTO_MEMORY_SOURCES = new Set(["auto-memory", "chat.message"]);
+const EXCLUDED_BROWSER_STATUSES = new Set(["rejected", "superseded", "private", "needs-clarification"]);
+const DEFAULT_BUILT_AT = "1970-01-01T00:00:00.000Z";
+
+function normalizeScalar(value, maxLength = 240) {
+  const normalized = String(value ?? "")
+    .replace(/\r?\n/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+
+  if (!normalized) return "";
+  return redactSecrets(normalized).slice(0, maxLength);
+}
+
+function normalizeText(value, maxLength = 240) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeScalar(item, maxLength)).filter(Boolean).join(" ");
+  }
+  return normalizeScalar(value, maxLength);
+}
+
+function normalizeTags(value) {
+  const tags = Array.isArray(value) ? value : [value];
+  return tags.map((tag) => normalizeScalar(tag, 80)).filter(Boolean);
+}
+
+function normalizeStatus(value) {
+  return normalizeScalar(value || "candidate", 80).toLowerCase() || "candidate";
+}
+
+function normalizeSource(value) {
+  return normalizeScalar(value, 120).toLowerCase();
+}
+
+function normalizeRelativePath(value) {
+  if (!value || typeof value !== "string") return null;
+  const normalized = value.replace(/\\/g, "/");
+  if (path.isAbsolute(normalized)) return null;
+  if (normalized.split("/").some((segment) => segment === "..")) return null;
+  return normalized;
+}
+
+function toRelativePath(wikiRoot, filePath) {
+  return normalizeRelativePath(path.relative(wikiRoot, filePath));
+}
+
+function hasSafeDate(value) {
+  return typeof value === "string" && value.trim() && !Number.isNaN(Date.parse(value));
+}
+
+function deterministicBuiltAt(records, graph) {
+  const dates = [];
+
+  for (const record of records) {
+    for (const value of [record.created_at, record.updated_at, record.promoted_at]) {
+      if (hasSafeDate(value)) dates.push(value);
+    }
+  }
+
+  if (hasSafeDate(graph?.meta?.built_at)) dates.push(graph.meta.built_at);
+  if (dates.length === 0) return DEFAULT_BUILT_AT;
+  return dates.sort((a, b) => a.localeCompare(b)).at(-1);
+}
+
+function addSourceMetadata(entry, frontmatter) {
+  const source = normalizeSource(frontmatter.source);
+  if (source) entry.source = source;
+
+  for (const key of ["source_session", "source_agent", "capture_reason"]) {
+    const value = normalizeText(frontmatter[key], 240);
+    if (value) entry[key] = value;
+  }
+}
+
+function scanDirectory(wikiRoot, directory, category) {
+  if (!fs.existsSync(directory)) return [];
+
+  const results = [];
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...scanDirectory(wikiRoot, entryPath, category));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      try {
+        const relativePath = toRelativePath(wikiRoot, entryPath);
+        if (!relativePath) continue;
+
+        const content = fs.readFileSync(entryPath, "utf-8");
+        const { frontmatter } = parseFrontmatter(content);
+        const title = normalizeText(frontmatter.title, 180);
+        if (!title) continue;
+
+        const item = {
+          path: relativePath,
+          category,
+          title,
+          tags: normalizeTags(frontmatter.tags),
+          status: normalizeStatus(frontmatter.status),
+        };
+        addSourceMetadata(item, frontmatter);
+
+        results.push({
+          entry: item,
+          created_at: normalizeScalar(frontmatter.created_at, 80),
+          updated_at: normalizeScalar(frontmatter.updated_at, 80),
+          promoted_at: normalizeScalar(frontmatter.promoted_at, 80),
+        });
+      } catch {
+        // Skip unreadable files
+      }
+    }
+  }
+
+  return results.sort((a, b) => a.entry.path.localeCompare(b.entry.path));
+}
+
+function scanEntries(wikiRoot) {
+  const paths = getWikiPaths(wikiRoot);
+  return [
+    ...scanDirectory(wikiRoot, paths.inbox, "inbox"),
+    ...scanDirectory(wikiRoot, paths.problems, "problems"),
+    ...scanDirectory(wikiRoot, paths.lessons, "lessons"),
+  ].sort((a, b) => a.entry.path.localeCompare(b.entry.path));
+}
+
+function isBrowserVisible(entry) {
+  return !EXCLUDED_BROWSER_STATUSES.has(entry.status);
+}
+
+function isAutoMemoryEntry(entry) {
+  return AUTO_MEMORY_SOURCES.has(entry.source);
+}
+
+function readGraph(wikiRoot) {
+  const graphPath = path.join(wikiRoot, ".system", "graph.json");
+  try {
+    return JSON.parse(fs.readFileSync(graphPath, "utf-8"));
+  } catch {
+    return { nodes: [], edges: [], communities: [], meta: {} };
+  }
+}
+
+function sanitizeDuplicates(duplicates) {
+  return duplicates
+    .map((duplicate) => {
+      const warning = {
+        type: normalizeScalar(duplicate.type, 40) || "unknown",
+        entries: (duplicate.entries || [])
+          .map(normalizeRelativePath)
+          .filter(Boolean)
+          .sort((a, b) => a.localeCompare(b)),
+      };
+
+      const normalizedTitle = normalizeScalar(duplicate.normalized_title, 160);
+      const hash = normalizeScalar(duplicate.hash, 80);
+      if (normalizedTitle) warning.normalized_title = normalizedTitle;
+      if (hash) warning.hash = hash;
+      return warning;
+    })
+    .filter((warning) => warning.entries.length > 0)
+    .sort((a, b) => {
+      const left = `${a.type}:${a.normalized_title || a.hash || ""}:${a.entries.join("|")}`;
+      const right = `${b.type}:${b.normalized_title || b.hash || ""}:${b.entries.join("|")}`;
+      return left.localeCompare(right);
+    });
+}
+
+function sanitizeCommunities(graph) {
+  const communities = Array.isArray(graph?.communities) ? graph.communities : [];
+  return communities
+    .map((community) => {
+      const members = (community.members || [])
+        .map(normalizeRelativePath)
+        .filter(Boolean)
+        .sort((a, b) => a.localeCompare(b));
+
+      return {
+        id: normalizeScalar(community.id, 120),
+        label: normalizeScalar(community.label || community.id, 120),
+        members,
+        color: normalizeScalar(community.color, 40),
+      };
+    })
+    .filter((community) => community.id && community.members.length > 0)
+    .sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function sanitizeGraphGaps(graph) {
+  const nodes = Array.isArray(graph?.nodes) ? graph.nodes : [];
+  return nodes
+    .map((node) => {
+      const nodePath = normalizeRelativePath(node.path || node.id);
+      if (!nodePath) return null;
+      const degree = Number.isFinite(node.degree) ? Math.max(0, Math.trunc(node.degree)) : 0;
+      return {
+        path: nodePath,
+        title: normalizeText(node.label || node.title || node.id, 180),
+        degree,
+        reason: degree === 0 ? "isolated" : "under-connected",
+      };
+    })
+    .filter((gap) => gap && gap.degree < 2)
+    .sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function buildDuplicateEntries(entries) {
+  return entries.map((entry) => ({
+    path: entry.path,
+    title: normalizeText(entry.title, 180),
+  }));
+}
+
+export function buildBrowserData(wikiRoot) {
+  const paths = getWikiPaths(wikiRoot);
+  ensureWikiStructure(paths);
+
+  const records = scanEntries(wikiRoot);
+  const visibleRecords = records.filter((record) => isBrowserVisible(record.entry));
+  const visibleEntries = visibleRecords.map((record) => record.entry);
+  const graph = readGraph(wikiRoot);
+
+  const candidates = visibleEntries.filter((entry) => entry.category === "inbox" && entry.status === "candidate");
+  const lessons = visibleEntries.filter((entry) => entry.category === "lessons");
+  const autoMemoryCaptures = visibleEntries.filter(isAutoMemoryEntry);
+  const autoMemoryCandidateCount = candidates.filter(isAutoMemoryEntry).length;
+  const duplicates = sanitizeDuplicates(detectDuplicates(buildDuplicateEntries(visibleEntries), wikiRoot));
+
+  return {
+    candidates,
+    auto_memory_captures: autoMemoryCaptures,
+    lessons,
+      duplicates,
+      communities: sanitizeCommunities(graph),
+      graph_gaps: sanitizeGraphGaps(graph),
+      todo: buildTodoBrowserData(wikiRoot),
+      agent_team: buildAgentTeamBrowserData(wikiRoot),
+      curator: buildCuratorBrowserData(wikiRoot),
+      stage4_graph_reasoning: buildGraphReasoningBrowserData(wikiRoot),
+      meta: {
+      built_at: deterministicBuiltAt(visibleRecords, graph),
+      file_count: visibleEntries.length,
+      candidate_count: candidates.length,
+      lesson_count: lessons.length,
+      auto_memory_candidate_count: autoMemoryCandidateCount,
+    },
+  };
+}
+
+export function writeBrowserData(wikiRoot, browserData = buildBrowserData(wikiRoot)) {
+  const paths = getWikiPaths(wikiRoot);
+  ensureWikiStructure(paths);
+
+  const browserDataPath = path.join(paths.system, "browser-data.json");
+  const tmpFile = `${browserDataPath}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  fs.writeFileSync(tmpFile, JSON.stringify(browserData, null, 2));
+  fs.renameSync(tmpFile, browserDataPath);
+
+  return {
+    path: BROWSER_DATA_RELATIVE_PATH,
+    data: browserData,
+  };
+}
+
+export function rebuildBrowserData(wikiRoot) {
+  return writeBrowserData(wikiRoot, buildBrowserData(wikiRoot));
+}

package/src/wiki/doctor.js

@@ -0,0 +1,218 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseFrontmatter } from "./store.js";
+import {
+  VALID_SOURCES,
+  VALID_STATUSES,
+  normalizeEntrySource,
+  normalizeEntryStatus,
+  normalizeEntryTags,
+  normalizeEntryText,
+  normalizeWikiIndex,
+} from "./entry-normalizer.js";
+
+const ENTRY_DIRECTORIES = ["inbox", "problems", path.join("editorial", "lessons")];
+
+function typeOfField(value) {
+  if (Array.isArray(value)) return "array";
+  if (value === null) return "null";
+  return typeof value;
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function relativePath(rootDir, fullPath) {
+  return path.relative(rootDir, fullPath).replace(/\\/g, "/");
+}
+
+function collectMarkdownFiles(wikiRoot) {
+  const files = [];
+
+  function visit(directory) {
+    if (!fs.existsSync(directory)) return;
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const fullPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        visit(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  for (const entryDirectory of ENTRY_DIRECTORIES) {
+    visit(path.join(wikiRoot, entryDirectory));
+  }
+
+  return files.sort((left, right) => left.localeCompare(right));
+}
+
+function createIssue(field, kind, value, normalizedValue, message) {
+  return {
+    field,
+    kind,
+    value_type: typeOfField(value),
+    normalized_value: normalizedValue,
+    message,
+  };
+}
+
+function inspectTitle(value) {
+  if (value === undefined || value === null || normalizeEntryText(value) === "") {
+    return createIssue("title", "missing", value, "", "Title is missing and needs review before indexing.");
+  }
+  if (Array.isArray(value)) {
+    return createIssue("title", "array", value, normalizeEntryText(value), "Title is an array and should be stored as a scalar string.");
+  }
+  if (isRecord(value)) {
+    return createIssue("title", "object", value, normalizeEntryText(value), "Title is an object and should be reviewed before conversion.");
+  }
+  return null;
+}
+
+function inspectTags(value) {
+  if (value === undefined || value === null) {
+    return createIssue("tags", "missing", value, [], "Tags are missing; add an explicit reviewed tag list.");
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return createIssue("tags", "scalar", value, normalizeEntryTags(value), "Tags are scalar and should be stored as a list.");
+  }
+  if (isRecord(value)) {
+    return createIssue("tags", "object", value, normalizeEntryTags(value), "Tags are an object and should be manually mapped to a list.");
+  }
+  return null;
+}
+
+function inspectStatus(value) {
+  if (value === undefined || value === null || normalizeEntryText(value) === "") {
+    return createIssue("status", "missing", value, normalizeEntryStatus(value), "Status is missing; candidate is the safe fallback.");
+  }
+  const normalized = normalizeEntryStatus(value);
+  if (Array.isArray(value) || isRecord(value) || !VALID_STATUSES.includes(normalizeEntryText(value).toLowerCase())) {
+    return createIssue("status", "invalid", value, normalized, "Status is invalid and will fall back to candidate until reviewed.");
+  }
+  return null;
+}
+
+function inspectSource(value) {
+  if (value === undefined || value === null || normalizeEntryText(value) === "") {
+    return createIssue("source", "missing", value, normalizeEntrySource(value), "Source is missing; manual is the safe fallback.");
+  }
+  const normalized = normalizeEntrySource(value);
+  if (Array.isArray(value) || isRecord(value) || !VALID_SOURCES.includes(normalizeEntryText(value).toLowerCase())) {
+    return createIssue("source", "invalid", value, normalized, "Source is invalid and will fall back to manual until reviewed.");
+  }
+  return null;
+}
+
+function inspectFields(fields) {
+  return [
+    inspectTitle(fields.title),
+    inspectTags(fields.tags),
+    inspectStatus(fields.status),
+    inspectSource(fields.source),
+  ].filter(Boolean);
+}
+
+function addMalformedEntry(malformedEntries, scope, entryPath, issues) {
+  if (issues.length === 0) return;
+  malformedEntries.push({
+    scope,
+    path: entryPath,
+    issues,
+  });
+}
+
+function readCachedIndex(wikiRoot, warnings) {
+  const indexPath = path.join(wikiRoot, ".system", "index.json");
+  if (!fs.existsSync(indexPath)) return null;
+
+  try {
+    return JSON.parse(fs.readFileSync(indexPath, "utf-8"));
+  } catch (error) {
+    warnings.push(`Unable to parse cached index: ${error.message}`);
+    return null;
+  }
+}
+
+function migrationActionForIssue(entry, issue) {
+  return {
+    action: "review_entry_field",
+    scope: entry.scope,
+    path: entry.path,
+    field: issue.field,
+    issue: issue.kind,
+    normalized_value: issue.normalized_value,
+    review_required: true,
+  };
+}
+
+function buildMigrationPlan(malformedEntries) {
+  return {
+    review_required: true,
+    dry_run: true,
+    mutations_performed: 0,
+    actions: malformedEntries.flatMap((entry) => entry.issues.map((issue) => migrationActionForIssue(entry, issue))),
+  };
+}
+
+export function doctorWiki(wikiRoot) {
+  const normalizedRoot = path.resolve(wikiRoot);
+  const warnings = [];
+  const malformedEntries = [];
+  let entriesChecked = 0;
+
+  if (!fs.existsSync(normalizedRoot)) {
+    return {
+      success: false,
+      wiki_root: normalizedRoot,
+      entries_checked: 0,
+      malformed_entries: [],
+      warnings: [`Wiki root does not exist: ${normalizedRoot}`],
+      migration_plan: buildMigrationPlan([]),
+    };
+  }
+
+  for (const filePath of collectMarkdownFiles(normalizedRoot)) {
+    entriesChecked += 1;
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const { frontmatter } = parseFrontmatter(content);
+      addMalformedEntry(malformedEntries, "markdown", relativePath(normalizedRoot, filePath), inspectFields(frontmatter));
+    } catch (error) {
+      warnings.push(`Unable to inspect ${relativePath(normalizedRoot, filePath)}: ${error.message}`);
+    }
+  }
+
+  const cachedIndex = readCachedIndex(normalizedRoot, warnings);
+  if (cachedIndex) {
+    const entries = Array.isArray(cachedIndex.entries) ? cachedIndex.entries : [];
+    const normalizedIndex = normalizeWikiIndex(cachedIndex);
+    entries.forEach((entry, entryIndex) => {
+      entriesChecked += 1;
+      const normalizedEntry = normalizedIndex.entries[entryIndex];
+      const entryPath = normalizeEntryText(entry?.path) || normalizedEntry?.path || `.system/index.json#entry-${entryIndex}`;
+      addMalformedEntry(
+        malformedEntries,
+        "cached_index",
+        `.system/index.json#${entryPath}`,
+        inspectFields(entry)
+      );
+    });
+  }
+
+  const migrationPlan = buildMigrationPlan(malformedEntries);
+  return {
+    success: true,
+    wiki_root: normalizedRoot,
+    entries_checked: entriesChecked,
+    malformed_entries: malformedEntries,
+    warnings,
+    migration_plan: migrationPlan,
+    message: malformedEntries.length === 0
+      ? `Doctor checked ${entriesChecked} entries; no malformed entry fields found.`
+      : `Doctor checked ${entriesChecked} entries; ${malformedEntries.length} entries need review.`,
+  };
+}