@codyswann/lisa 4.74.8 → 4.75.0

package/plugins/lisa-wiki-devin/scripts/wiki-safety.mjs

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+/**
+ * Deterministic wiki source safety helpers.
+ *
+ * This module intentionally uses only Node built-ins and pure string scanning so
+ * downstream wiki connectors can run the same redaction pass before persisting
+ * reader-safe source notes.
+ */
+
+const PLACEHOLDERS = {
+  ssn: "[REDACTED:SSN]",
+  credit_card: "[REDACTED:CREDIT_CARD]",
+  private_key: "[REDACTED:PRIVATE_KEY]",
+  password: "[REDACTED:PASSWORD]",
+  api_key: "[REDACTED:API_KEY]",
+  oauth_token: "[REDACTED:OAUTH_TOKEN]",
+  bank_account: "[REDACTED:BANK_ACCOUNT]",
+  routing_number: "[REDACTED:ROUTING_NUMBER]",
+};
+
+const PATTERNS = [
+  {
+    entityType: "private_key",
+    confidence: "high",
+    re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/g,
+  },
+  {
+    entityType: "ssn",
+    confidence: "high",
+    re: /\b(?!000|666|9\d\d)\d{3}-(?!00)\d{2}-(?!0000)\d{4}\b/g,
+  },
+  {
+    entityType: "password",
+    confidence: "high",
+    re: /\b(?:password|passwd|pwd)\s*[:=]\s*(['"]?)([^\s'",;]{8,})\1/gi,
+    valueGroup: 2,
+  },
+  {
+    entityType: "api_key",
+    confidence: "medium",
+    re: /\b(?:api[_-]?key|access[_-]?key|secret[_-]?key|client[_-]?secret)\s*[:=]\s*(['"]?)([A-Za-z0-9._-]{20,})\1/gi,
+    valueGroup: 2,
+  },
+  {
+    entityType: "oauth_token",
+    confidence: "high",
+    re: /\b(?:oauth[_-]?token|refresh[_-]?token|access[_-]?token|bearer)\s*[:= ]\s*(['"]?)([A-Za-z0-9._-]{24,})\1/gi,
+    valueGroup: 2,
+  },
+  {
+    entityType: "routing_number",
+    confidence: "medium",
+    re: /\b(?:routing|routing_number|aba)\s*(?:number|no\.?)?\s*[:#=]?\s*(\d{9})\b/gi,
+    valueGroup: 1,
+  },
+  {
+    entityType: "bank_account",
+    confidence: "medium",
+    re: /\b(?:bank\s+)?(?:account|acct)\s*(?:number|no\.?)?\s*[:#=]?\s*(\d{6,17})\b/gi,
+    valueGroup: 1,
+  },
+];
+
+const TEXTISH_EXTS = new Set([
+  ".md",
+  ".mdx",
+  ".json",
+  ".jsonl",
+  ".txt",
+  ".yml",
+  ".yaml",
+  ".toml",
+  ".csv",
+  ".tsv",
+]);
+
+function luhnValid(candidate) {
+  const digits = candidate.replace(/\D/g, "");
+  if (digits.length < 13 || digits.length > 19) return false;
+  let sum = 0;
+  let doubleDigit = false;
+  for (let i = digits.length - 1; i >= 0; i -= 1) {
+    let n = Number(digits[i]);
+    if (doubleDigit) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    doubleDigit = !doubleDigit;
+  }
+  return sum % 10 === 0;
+}
+
+function applyFinding(text, match, pattern) {
+  const raw = match[0];
+  const value = pattern.valueGroup ? match[pattern.valueGroup] : raw;
+  const valueOffset = pattern.valueGroup ? raw.indexOf(value) : 0;
+  const start = match.index + valueOffset;
+  const end = start + value.length;
+  return {
+    sanitized:
+      text.slice(0, start) + PLACEHOLDERS[pattern.entityType] + text.slice(end),
+    finding: {
+      entityType: pattern.entityType,
+      confidence: pattern.confidence,
+      range: { start, end },
+    },
+    delta: PLACEHOLDERS[pattern.entityType].length - value.length,
+  };
+}
+
+function collectCreditCardFindings(text) {
+  const findings = [];
+  const re = /\b(?:\d[ -]?){13,19}\b/g;
+  let match;
+  while ((match = re.exec(text)) !== null) {
+    const value = match[0].trim();
+    if (!luhnValid(value)) continue;
+    findings.push({
+      entityType: "credit_card",
+      confidence: "high",
+      range: { start: match.index, end: match.index + match[0].length },
+    });
+  }
+  return findings;
+}
+
+function summarizeFindings(sourceMetadata, findings) {
+  const sourceId =
+    sourceMetadata.sourceId ??
+    sourceMetadata.id ??
+    sourceMetadata.path ??
+    sourceMetadata.url ??
+    "unknown";
+  const byType = new Map();
+  for (const finding of findings) {
+    const current = byType.get(finding.entityType) ?? {
+      sourceId,
+      entityType: finding.entityType,
+      confidence: finding.confidence,
+      count: 0,
+      ranges: [],
+    };
+    current.count += 1;
+    current.ranges.push(finding.range);
+    byType.set(finding.entityType, current);
+  }
+  return [...byType.values()].sort((a, b) =>
+    a.entityType.localeCompare(b.entityType)
+  );
+}
+
+function collectFindings(rawText) {
+  const text = String(rawText ?? "");
+  const findings = [];
+
+  for (const pattern of PATTERNS) {
+    pattern.re.lastIndex = 0;
+    let match;
+    while ((match = pattern.re.exec(text)) !== null) {
+      findings.push(applyFinding(text, match, pattern).finding);
+    }
+  }
+  findings.push(...collectCreditCardFindings(text));
+  findings.sort((a, b) => a.range.start - b.range.start);
+  return findings;
+}
+
+export function scanWikiSourceText(rawText, sourceMetadata = {}) {
+  const findings = collectFindings(rawText);
+
+  return {
+    sourceId:
+      sourceMetadata.sourceId ??
+      sourceMetadata.id ??
+      sourceMetadata.path ??
+      sourceMetadata.url ??
+      "unknown",
+    reviewRequired: findings.length > 0,
+    findings: summarizeFindings(sourceMetadata, findings),
+  };
+}
+
+export function sanitizeWikiSourceText(rawText, sourceMetadata = {}) {
+  let sanitized = String(rawText ?? "");
+  const rawFindings = collectFindings(rawText);
+  for (const finding of [...rawFindings].sort(
+    (a, b) => b.range.start - a.range.start
+  )) {
+    sanitized =
+      sanitized.slice(0, finding.range.start) +
+      PLACEHOLDERS[finding.entityType] +
+      sanitized.slice(finding.range.end);
+  }
+
+  return {
+    text: sanitized,
+    reviewRequired: rawFindings.length > 0,
+    findings: summarizeFindings(sourceMetadata, rawFindings),
+  };
+}
+
+export function processWikiSourceNote(rawText, options = {}) {
+  const {
+    dryRun = false,
+    scannerAvailable = true,
+    scannerRequired = false,
+    ...sourceMetadata
+  } = options;
+  const sanitized = sanitizeWikiSourceText(rawText, sourceMetadata);
+  const scannerBlocked = scannerRequired && !scannerAvailable;
+
+  return {
+    ...sanitized,
+    dryRun: Boolean(dryRun),
+    writeAllowed: !dryRun && !scannerBlocked,
+    scanner: {
+      available: Boolean(scannerAvailable),
+      required: Boolean(scannerRequired),
+      blocked: scannerBlocked,
+    },
+    blockedReason: scannerBlocked
+      ? "sensitivity scanner is required but unavailable"
+      : undefined,
+  };
+}
+
+export function serializeWikiSafetyFindings(result) {
+  return JSON.stringify(
+    {
+      reviewRequired: Boolean(result?.reviewRequired),
+      findings: Array.isArray(result?.findings) ? result.findings : [],
+    },
+    null,
+    2
+  );
+}
+
+function normalizeSafetyResults(results) {
+  if (Array.isArray(results)) return results;
+  if (!results) return [];
+  return [results];
+}
+
+function summarizeEntityTypes(results) {
+  const byType = new Map();
+  for (const result of results) {
+    for (const finding of result?.findings ?? []) {
+      const entityType = finding?.entityType ?? "unknown";
+      const current = byType.get(entityType) ?? {
+        entityType,
+        confidence: finding?.confidence ?? "unknown",
+        count: 0,
+      };
+      current.count += Number.isFinite(finding?.count) ? finding.count : 1;
+      if (current.confidence !== "high" && finding?.confidence === "high") {
+        current.confidence = "high";
+      }
+      byType.set(entityType, current);
+    }
+  }
+  return [...byType.values()].sort((a, b) =>
+    a.entityType.localeCompare(b.entityType)
+  );
+}
+
+export function createWikiIngestPublicationPolicy(options = {}) {
+  const safetyResults = normalizeSafetyResults(options.safetyResults);
+  const externalWrite = Boolean(options.externalWrite);
+  const entityTypes = summarizeEntityTypes(safetyResults);
+  const findingCount = entityTypes.reduce((sum, item) => sum + item.count, 0);
+  const reviewRequired =
+    externalWrite ||
+    findingCount > 0 ||
+    safetyResults.some(result => Boolean(result?.reviewRequired));
+  const reasons = [
+    ...(externalWrite ? ["external-write source"] : []),
+    ...(findingCount > 0 ? ["redacted or sensitive findings"] : []),
+    ...(!externalWrite &&
+    findingCount === 0 &&
+    safetyResults.some(result => Boolean(result?.reviewRequired))
+      ? ["source safety review requested"]
+      : []),
+  ];
+
+  const findingLines =
+    entityTypes.length > 0
+      ? entityTypes.map(
+          item =>
+            `- ${item.entityType}: ${item.count} ${item.count === 1 ? "finding" : "findings"} (${item.confidence})`
+        )
+      : ["- none"];
+
+  return {
+    autoMergeAllowed: !reviewRequired,
+    reviewRequired,
+    reasons,
+    findingCount,
+    entityTypes,
+    prSummaryMarkdown: [
+      "## Wiki Safety Review",
+      "",
+      `Auto-merge: ${reviewRequired ? "disabled" : "allowed"}`,
+      `Human review required: ${reviewRequired ? "yes" : "no"}`,
+      `Reason: ${reasons.length > 0 ? reasons.join("; ") : "no redactions or sensitive findings"}`,
+      "",
+      "Finding summary:",
+      ...findingLines,
+      "",
+      "Raw sensitive values are intentionally omitted from this summary.",
+    ].join("\n"),
+  };
+}
+
+export function isWikiSafetyScanTarget(filePath, options = {}) {
+  const pathModule = options.pathModule;
+  if (!pathModule) {
+    throw new Error("isWikiSafetyScanTarget requires options.pathModule");
+  }
+  const wikiRoot = pathModule.resolve(options.wikiRoot ?? "wiki");
+  const resolved = pathModule.resolve(filePath);
+  const relative = pathModule.relative(wikiRoot, resolved);
+  if (
+    !relative ||
+    relative.startsWith("..") ||
+    pathModule.isAbsolute(relative)
+  ) {
+    return false;
+  }
+  const ext = pathModule.extname(resolved);
+  return TEXTISH_EXTS.has(ext);
+}
+
+export function scanWikiGeneratedFiles(files, options = {}) {
+  const fsModule = options.fsModule;
+  const pathModule = options.pathModule;
+  if (!fsModule || !pathModule) {
+    throw new Error("scanWikiGeneratedFiles requires fsModule and pathModule");
+  }
+
+  const wikiRoot = pathModule.resolve(options.wikiRoot ?? "wiki");
+  const candidates = [...new Set(files.map(file => pathModule.resolve(file)))]
+    .filter(file => isWikiSafetyScanTarget(file, { wikiRoot, pathModule }))
+    .sort();
+
+  const scanned = [];
+  const findings = [];
+  const errors = [];
+
+  for (const file of candidates) {
+    let text;
+    try {
+      if (!fsModule.existsSync(file) || !fsModule.statSync(file).isFile()) {
+        continue;
+      }
+      text = fsModule.readFileSync(file, "utf8");
+    } catch (error) {
+      errors.push({
+        file: pathModule.relative(process.cwd(), file),
+        message: error instanceof Error ? error.message : String(error),
+      });
+      continue;
+    }
+
+    const sourceId = pathModule.relative(wikiRoot, file);
+    scanned.push(sourceId);
+    const result = scanWikiSourceText(text, { sourceId });
+    findings.push(...result.findings);
+  }
+
+  return {
+    ok: findings.length === 0 && errors.length === 0,
+    wikiRoot: pathModule.relative(process.cwd(), wikiRoot) || ".",
+    scanned,
+    findings,
+    errors,
+  };
+}

package/plugins/lisa-wiki-devin/scripts/wiki-status.mjs

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+/**
+ * wiki-status.mjs — read-only Lisa wiki source freshness report.
+ *
+ * Usage: node wiki-status.mjs [--wiki <wikiRoot>] [--config <path>] [--json]
+ * Exit 0 = report rendered. Missing wiki/config are represented in the report.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig, walkFiles } from "./_wiki-lib.mjs";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_STALE_AFTER_DAYS = 7;
+
+const argv = process.argv.slice(2);
+const flag = name => argv.includes(name);
+const opt = name => {
+  const i = argv.indexOf(name);
+  return i !== -1 ? argv[i + 1] : undefined;
+};
+
+function relToCwd(filePath) {
+  return path.relative(process.cwd(), filePath).replaceAll(path.sep, "/");
+}
+
+function relToWikiParent(filePath, wikiRoot) {
+  const wikiParent = path.dirname(wikiRoot);
+  return normalizeWikiPath(path.relative(wikiParent, filePath));
+}
+
+function normalizeWikiPath(filePath) {
+  return filePath.replaceAll("\\", "/").replace(/^\.?\//, "");
+}
+
+function parseDate(value) {
+  if (!value || typeof value !== "string") return undefined;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+}
+
+function newestDate(values) {
+  return values
+    .map(parseDate)
+    .filter(Boolean)
+    .sort((a, b) => b.getTime() - a.getTime())[0];
+}
+
+function readTextSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function enabledConnectors(config) {
+  const connectors = config?.connectors ?? {};
+  return Object.entries(connectors)
+    .filter(([, connectorConfig]) => connectorConfig?.enabled !== false)
+    .filter(
+      ([, connectorConfig]) => connectorConfig?.sideEffects !== "external-write"
+    )
+    .map(([name, connectorConfig]) => ({
+      name,
+      sideEffects: connectorConfig?.sideEffects ?? "unknown",
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function logSections(logText) {
+  const lines = logText.split("\n");
+  const sections = [];
+  let current;
+
+  for (const line of lines) {
+    const heading = line.match(/^##\s+(\d{4}-\d{2}-\d{2})(?:\s+-\s+(.*))?$/);
+    if (heading) {
+      if (current) sections.push(current);
+      current = {
+        date: heading[1],
+        title: heading[2] ?? "",
+        lines: [line],
+      };
+      continue;
+    }
+    if (current) current.lines.push(line);
+  }
+
+  if (current) sections.push(current);
+  return sections;
+}
+
+function connectorLogFacts(logText, connectorName) {
+  const sections = logSections(logText);
+  const escaped = connectorName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const quoted = new RegExp(`\`${escaped}\``, "i");
+  const bare = new RegExp(`\\b${escaped}\\b`, "i");
+
+  for (const section of [...sections].reverse()) {
+    const lines = section.lines.filter(
+      line => quoted.test(line) || bare.test(line)
+    );
+    if (lines.length === 0) continue;
+
+    const lower = lines.join("\n").toLowerCase();
+    const status = lower.includes("skipped")
+      ? "skipped"
+      : lower.includes("blocked") || lower.includes("failed")
+        ? "blocked"
+        : lower.includes("ingested") || lower.includes("refreshed")
+          ? "ingested"
+          : "observed";
+
+    return {
+      date: section.date,
+      status,
+      reason: lines.map(line => line.replace(/^-\s*/, "").trim()).join(" "),
+    };
+  }
+
+  return undefined;
+}
+
+function stateFacts(wikiRoot, connectorName) {
+  const stateDir = path.join(wikiRoot, "state", connectorName);
+  const files = walkFiles(stateDir, { ext: ".json" });
+  const states = files
+    .map(filePath => ({ filePath, data: readJsonSafe(filePath) }))
+    .filter(item => item.data);
+  const dated = states
+    .map(item => ({
+      ...item,
+      date:
+        parseDate(item.data.ingested_at) ??
+        parseDate(item.data.cursor?.lastIngest) ??
+        parseDate(item.data.updated_at),
+    }))
+    .sort((a, b) => (b.date?.getTime() ?? 0) - (a.date?.getTime() ?? 0));
+  const latest = dated[0] ?? states[0];
+  const sourceNotes = new Set();
+
+  for (const item of states) {
+    const notes = item.data.source_notes ?? item.data.sourceNotes ?? [];
+    if (Array.isArray(notes)) {
+      for (const note of notes) {
+        if (typeof note === "string") sourceNotes.add(normalizeWikiPath(note));
+      }
+    }
+    if (typeof item.data.source_note === "string") {
+      sourceNotes.add(normalizeWikiPath(item.data.source_note));
+    }
+  }
+
+  return {
+    stateFiles: files.map(filePath => relToWikiParent(filePath, wikiRoot)),
+    latestObservedAt: latest?.date?.toISOString() ?? latest?.data?.ingested_at,
+    sourceNotes: [...sourceNotes],
+  };
+}
+
+function sourceFacts(wikiRoot, connectorName, configuredSourceNotes) {
+  const sourceDir = path.join(wikiRoot, "sources", connectorName);
+  const markdownFiles = walkFiles(sourceDir, { ext: ".md" });
+  const wikiParent = path.dirname(wikiRoot);
+  const sourceNoteExists = note =>
+    fs.existsSync(path.resolve(note)) ||
+    fs.existsSync(path.resolve(wikiParent, note));
+  const existingConfigured = configuredSourceNotes.filter(note =>
+    sourceNoteExists(note)
+  );
+
+  return {
+    sourceNotes:
+      existingConfigured.length > 0
+        ? existingConfigured
+        : markdownFiles.map(filePath => relToWikiParent(filePath, wikiRoot)),
+  };
+}
+
+function nextActionFor(verdict, connectorName, reason) {
+  if (verdict === "fresh") return "No action needed.";
+  if (verdict === "skipped") {
+    return reason?.toLowerCase().includes("project-scoped memory")
+      ? "Provide project-scoped memory for this repo, or accept the expected skip."
+      : `Review the skip reason, then run /lisa-wiki:ingest --source ${connectorName} when available.`;
+  }
+  if (verdict === "blocked") {
+    return `Resolve the blocker, then run /lisa-wiki:ingest --source ${connectorName}.`;
+  }
+  return `Run /lisa-wiki:ingest --source ${connectorName}.`;
+}
+
+export function createWikiFreshnessReport({
+  configPath = "wiki/lisa-wiki.config.json",
+  wikiRoot,
+  now = new Date(),
+  staleAfterDays = DEFAULT_STALE_AFTER_DAYS,
+} = {}) {
+  const parsed = parseWikiSourceFreshness({
+    configPath,
+    wikiRoot,
+    now,
+    staleAfterDays,
+  });
+
+  return {
+    generatedAt: now.toISOString(),
+    configPath: relToCwd(parsed.configPath),
+    wikiRoot: relToCwd(parsed.wikiRoot),
+    items: parsed.connectors.map(connector => ({
+      connector: connector.connector,
+      sideEffects: connector.sideEffects,
+      verdict: connector.verdict,
+      evidence: connector.evidencePaths,
+      lastObserved: connector.lastObservedDate ?? "unknown",
+      reason: connector.reason,
+      nextAction: connector.nextAction,
+    })),
+  };
+}
+
+export function parseWikiSourceFreshness({
+  configPath = "wiki/lisa-wiki.config.json",
+  wikiRoot,
+  now = new Date(),
+  staleAfterDays = DEFAULT_STALE_AFTER_DAYS,
+} = {}) {
+  const { config, configPath: resolvedConfigPath } = loadConfig(configPath);
+  const resolvedWikiRoot = path.resolve(wikiRoot ?? config?.wikiRoot ?? "wiki");
+  const logPath = path.join(resolvedWikiRoot, "log.md");
+  const logText = readTextSafe(logPath);
+  const connectors = enabledConnectors(config);
+  const staleAfterMs = staleAfterDays * DAY_MS;
+
+  const connectorRecords = connectors.map(connector => {
+    const state = stateFacts(resolvedWikiRoot, connector.name);
+    const sources = sourceFacts(
+      resolvedWikiRoot,
+      connector.name,
+      state.sourceNotes
+    );
+    const log = connectorLogFacts(logText, connector.name);
+    const observedDate =
+      newestDate([state.latestObservedAt, log?.date]) ??
+      newestDate(
+        sources.sourceNotes.map(note => note.match(/\d{4}-\d{2}-\d{2}/)?.[0])
+      );
+    const hasState = state.stateFiles.length > 0;
+    const hasSourceNotes = sources.sourceNotes.length > 0;
+    const isStale =
+      observedDate && now.getTime() - observedDate.getTime() > staleAfterMs;
+
+    const verdict =
+      log?.status === "blocked"
+        ? "blocked"
+        : log?.status === "skipped" && !hasState && !hasSourceNotes
+          ? "skipped"
+          : !hasState && !hasSourceNotes
+            ? "never_ingested"
+            : !hasState || !hasSourceNotes || isStale
+              ? "stale"
+              : "fresh";
+
+    const evidence = [
+      ...sources.sourceNotes,
+      ...state.stateFiles,
+      fs.existsSync(logPath)
+        ? relToWikiParent(logPath, resolvedWikiRoot)
+        : undefined,
+    ].filter(Boolean);
+
+    return {
+      connector: connector.name,
+      sideEffects: connector.sideEffects,
+      verdict,
+      evidencePaths: evidence,
+      lastObservedDate: observedDate?.toISOString().slice(0, 10),
+      reason: verdict === "fresh" ? "" : (log?.reason ?? ""),
+      nextAction: nextActionFor(verdict, connector.name, log?.reason),
+    };
+  });
+
+  return {
+    configPath: resolvedConfigPath,
+    wikiRoot: resolvedWikiRoot,
+    connectors: connectorRecords,
+  };
+}
+
+export function renderWikiFreshnessReport(report) {
+  const lines = [
+    "# Lisa wiki source freshness",
+    "",
+    `Generated: ${report.generatedAt}`,
+    `Config: ${report.configPath}`,
+    `Wiki root: ${report.wikiRoot}`,
+    "",
+    "| Connector | Verdict | Last observed | Evidence | Next action |",
+    "| --- | --- | --- | --- | --- |",
+  ];
+
+  for (const item of report.items) {
+    const evidence =
+      item.evidence.length > 0
+        ? item.evidence.slice(0, 3).join("<br>")
+        : "none";
+    lines.push(
+      `| ${item.connector} | ${item.verdict} | ${item.lastObserved} | ${evidence} | ${item.nextAction} |`
+    );
+    if (item.reason && item.verdict !== "fresh") {
+      lines.push(
+        `| ${item.connector} | reason | ${item.lastObserved} | log | ${item.reason} |`
+      );
+    }
+  }
+
+  lines.push(
+    "",
+    "Integrity follow-up: run /lisa-wiki:lint separately for broken links, stale claims, or structure issues."
+  );
+
+  return `${lines.join("\n")}\n`;
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const report = createWikiFreshnessReport({
+    configPath: opt("--config") ?? "wiki/lisa-wiki.config.json",
+    wikiRoot: opt("--wiki"),
+  });
+
+  if (flag("--json")) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    process.stdout.write(renderWikiFreshnessReport(report));
+  }
+}