metame-cli 1.5.26 → 1.6.1

package/scripts/wiki-cluster.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+function membershipHash(slugs) {
+  const sorted = [...slugs].sort().join(',');
+  return crypto.createHash('sha256').update(sorted).digest('hex');
+}
+
+function jaccardOverlap(setA, setB) {
+  const a = new Set(setA);
+  const b = new Set(setB);
+  let intersection = 0;
+  for (const x of a) if (b.has(x)) intersection++;
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Find existing cluster with Jaccard overlap > 0.5 with newMemberIds.
+ * Tie-break: prefer larger stored cluster.
+ */
+function findMatchingCluster(existingClusters, newMemberIds) {
+  let best = null;
+  let bestScore = 0.5; // strict threshold: must exceed 0.5
+  for (const cluster of existingClusters) {
+    const score = jaccardOverlap(cluster.memberIds, newMemberIds);
+    if (score > bestScore) {
+      best = cluster;
+      bestScore = score;
+    } else if (score === bestScore && best && cluster.memberIds.length > best.memberIds.length) {
+      best = cluster;
+    }
+  }
+  return best;
+}
+
+/**
+ * Build connected components from embeddings using cosine similarity threshold.
+ * @param {Array<{ slug: string, vector: Float32Array|number[] }>} embeddings
+ * @param {{ threshold?: number, minSize?: number }} options
+ * Uses union-find.
+ */
+function buildConnectedComponents(embeddings, { threshold = 0.75, minSize = 3 } = {}) {
+  const n = embeddings.length;
+  const slugs = embeddings.map(e => e.slug);
+  const parent = Object.fromEntries(slugs.map(s => [s, s]));
+
+  function find(x) {
+    if (parent[x] !== x) parent[x] = find(parent[x]);
+    return parent[x];
+  }
+  function union(x, y) { parent[find(x)] = find(y); }
+
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      if (cosineSimilarity(embeddings[i].vector, embeddings[j].vector) >= threshold) {
+        union(slugs[i], slugs[j]);
+      }
+    }
+  }
+
+  const groups = {};
+  for (const s of slugs) {
+    const root = find(s);
+    if (!groups[root]) groups[root] = [];
+    groups[root].push(s);
+  }
+
+  return Object.values(groups).filter(g => g.length >= minSize);
+}
+
+/**
+ * Fetch doc-level embeddings from content_chunks by averaging all chunk embeddings per page.
+ * @param {object} db - node:sqlite DatabaseSync instance
+ * @param {string[]} slugs
+ * @returns {Array<{ slug: string, vector: Float32Array }>} one entry per slug that has embeddings
+ */
+function getDocEmbeddings(db, slugs) {
+  if (slugs.length === 0) return [];
+  const placeholders = ',?'.repeat(slugs.length).slice(1);
+  const rows = db.prepare(
+    `SELECT page_slug, embedding FROM content_chunks WHERE page_slug IN (${placeholders}) AND embedding IS NOT NULL`
+  ).all(...slugs);
+
+  // Group rows by slug
+  const bySlug = {};
+  for (const row of rows) {
+    if (!bySlug[row.page_slug]) bySlug[row.page_slug] = [];
+    const buf = Buffer.isBuffer(row.embedding) ? row.embedding : Buffer.from(row.embedding);
+    if (buf.byteLength % 4 !== 0) continue; // skip corrupt/truncated embedding row
+    bySlug[row.page_slug].push(new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4));
+  }
+
+  // Average chunk vectors per slug
+  const result = [];
+  for (const [slug, vecs] of Object.entries(bySlug)) {
+    const dim = vecs[0].length;
+    const avg = new Float32Array(dim);
+    for (const v of vecs) {
+      for (let i = 0; i < dim; i++) avg[i] += v[i] / vecs.length;
+    }
+    result.push({ slug, vector: avg });
+  }
+  return result;
+}
+
+module.exports = { cosineSimilarity, buildConnectedComponents, jaccardOverlap,
+                   findMatchingCluster, membershipHash, getDocEmbeddings };

package/scripts/wiki-extract.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+const execFileAsync = promisify(execFile);
+
+function slugFromFilename(filePath) {
+  const base = path.basename(filePath, path.extname(filePath));
+  return base
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function extractMarkdownTitle(text) {
+  const m = text.match(/^#\s+(.+)$/m);
+  return m ? m[1].trim() : null;
+}
+
+async function extractText(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+
+  if (ext === '.md' || ext === '.txt') {
+    try {
+      const text = fs.readFileSync(filePath, 'utf8');
+      const title = ext === '.md' ? extractMarkdownTitle(text) : null;
+      return { text, title, extractor: 'direct', extractStatus: 'ok' };
+    } catch (err) {
+      return { text: '', title: null, extractor: 'direct', extractStatus: 'error', errorMessage: err.message };
+    }
+  }
+
+  if (ext === '.pdf') {
+    return extractPdf(filePath);
+  }
+
+  return {
+    text: '', title: null, extractor: 'unknown', extractStatus: 'error',
+    errorMessage: `Unsupported file type: ${ext}`,
+  };
+}
+
+async function extractPdf(filePath) {
+  const hasPdftotext = await checkCommand('pdftotext');
+
+  if (hasPdftotext) {
+    try {
+      const { stdout } = await execFileAsync('pdftotext', [filePath, '-'], { maxBuffer: 10 * 1024 * 1024 });
+      if (!stdout.trim()) {
+        return {
+          text: '', title: null, extractor: 'pdftotext', extractStatus: 'empty_or_scanned',
+          errorMessage: 'PDF produced no text — may be a scanned image. Install OCR for support.',
+        };
+      }
+      return { text: stdout, title: null, extractor: 'pdftotext', extractStatus: 'ok' };
+    } catch {
+      // fall through to pdf-parse
+    }
+  }
+
+  // Fallback: pdf-parse
+  try {
+    const pdfParse = require('pdf-parse');
+    const buf = fs.readFileSync(filePath);
+    const data = await pdfParse(buf);
+    if (!data.text.trim()) {
+      return {
+        text: '', title: null, extractor: 'pdf-parse', extractStatus: 'empty_or_scanned',
+        errorMessage: 'PDF produced no text — may be a scanned image.',
+      };
+    }
+    return { text: data.text, title: null, extractor: 'pdf-parse', extractStatus: 'ok' };
+  } catch (err) {
+    const hint = hasPdftotext ? '' : ' Install poppler for better PDF support: brew install poppler';
+    return {
+      text: '', title: null, extractor: 'pdf-parse', extractStatus: 'error',
+      errorMessage: err.message + hint,
+    };
+  }
+}
+
+/**
+ * Parse flat paper text into named sections.
+ *
+ * @param {string} text — raw extracted text (e.g. from pdftotext)
+ * @returns {{
+ *   abstract: string, introduction: string, method: string,
+ *   experiments: string, results: string, discussion: string,
+ *   conclusion: string, references: string, _fallback: boolean
+ * }}
+ * _fallback is true when fewer than 2 section headers were found;
+ * in that case the text is split into three equal chunks and returned
+ * under 'introduction', 'method', 'results' to guarantee non-empty input
+ * for downstream fact extraction.
+ */
+function extractSections(text) {
+  // Map from canonical key → regex patterns (case-insensitive, optional number prefix)
+  const PATTERNS = {
+    abstract:     /^(?:\d+[\.\s]+)?(?:abstract)\s*$/i,
+    introduction: /^(?:\d+[\.\s]+)?(?:introduction|background|overview)\s*$/i,
+    method:       /^(?:\d+[\.\s]+)?(?:method(?:s|ology)?|approach|proposed\s+method|framework|model|architecture)\s*$/i,
+    experiments:  /^(?:\d+[\.\s]+)?(?:experiments?|experimental\s+(?:setup|design)|evaluation|setup)\s*$/i,
+    results:      /^(?:\d+[\.\s]+)?(?:results?|findings|performance)\s*$/i,
+    discussion:   /^(?:\d+[\.\s]+)?(?:discussion|analysis|ablation)\s*$/i,
+    conclusion:   /^(?:\d+[\.\s]+)?(?:conclusions?|summary|future\s+work)\s*$/i,
+    references:   /^(?:\d+[\.\s]+)?(?:references|bibliography)\s*$/i,
+  };
+
+  const lines = text.split('\n');
+  const hits = []; // { key, lineIdx }
+
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.length > 80) continue; // section titles are short
+    for (const [key, re] of Object.entries(PATTERNS)) {
+      if (re.test(trimmed)) {
+        hits.push({ key, lineIdx: i });
+        break;
+      }
+    }
+  }
+
+  // Fallback: fewer than 2 distinct headers detected
+  if (hits.length < 2) {
+    const third = Math.floor(lines.length / 3);
+    return {
+      abstract: '',
+      introduction: lines.slice(0, third).join('\n'),
+      method: lines.slice(third, 2 * third).join('\n'),
+      experiments: '',
+      results: lines.slice(2 * third).join('\n'),
+      discussion: '',
+      conclusion: '',
+      references: '',
+      _fallback: true,
+    };
+  }
+
+  // Build sections from hits
+  const out = { abstract: '', introduction: '', method: '', experiments: '',
+                results: '', discussion: '', conclusion: '', references: '', _fallback: false };
+
+  for (let h = 0; h < hits.length; h++) {
+    const { key, lineIdx } = hits[h];
+    const endLine = h + 1 < hits.length ? hits[h + 1].lineIdx : lines.length;
+    // Deduplicate: keep the longest slice if same key appears twice
+    const chunk = lines.slice(lineIdx + 1, endLine).join('\n').trim();
+    if (chunk.length > (out[key] || '').length) out[key] = chunk;
+  }
+
+  return out;
+}
+
+async function checkCommand(cmd) {
+  // Use 'which' without shell:true to avoid shell injection
+  try {
+    await execFileAsync('which', [cmd]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sha256(input) {
+  return crypto.createHash('sha256').update(input).digest('hex');
+}
+
+module.exports = { extractText, extractSections, slugFromFilename, sha256 };

package/scripts/wiki-facts.js

@@ -0,0 +1,351 @@
+'use strict';
+
+/**
+ * wiki-facts.js — Paper fact extraction, persistence, and entity registration
+ *
+ * Single responsibility: turn structured paper sections into atomic facts
+ * stored in paper_facts + research_entities tables.
+ *
+ * Exports:
+ *   extractPaperFacts(db, docSource, sections, providers, opts)
+ *     → Promise<fact[]>   all facts written to DB for this doc
+ *
+ *   writeFacts(db, docSourceId, facts)
+ *     → void   idempotent batch INSERT (conflict ignore by id)
+ *
+ *   registerEntities(db, facts)
+ *     → void   INSERT OR IGNORE entities inferred from subject/object fields
+ *
+ *   buildTier1Prompt(title, facts)
+ *     → string   LLM prompt for Tier 1 wiki page generation
+ */
+
+const crypto = require('node:crypto');
+
+// ── Concurrency helper ────────────────────────────────────────────────────────
+// Hand-written semaphore — no external dependencies.
+async function withConcurrency(tasks, limit) {
+  const results = new Array(tasks.length);
+  let nextIdx = 0;
+
+  async function worker() {
+    while (nextIdx < tasks.length) {
+      const idx = nextIdx++;
+      try {
+        results[idx] = await tasks[idx]();
+      } catch (err) {
+        results[idx] = { error: err.message };
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(limit, tasks.length) }, worker));
+  return results;
+}
+
+// ── Section → LLM prompt ──────────────────────────────────────────────────────
+const FACT_TYPES = [
+  'problem', 'method', 'claim', 'assumption',
+  'dataset', 'metric', 'result', 'baseline',
+  'limitation', 'future_work', 'contradiction_note',
+];
+
+function buildSectionFactPrompt(sectionName, sectionText, paperTitle) {
+  const truncated = sectionText.length > 4000
+    ? sectionText.slice(0, 4000) + '\n[...truncated]'
+    : sectionText;
+
+  return `You are extracting structured facts from a section of an academic paper.
+
+Paper title: ${paperTitle}
+Section: ${sectionName}
+
+Section text:
+${truncated}
+
+Extract all atomic, verifiable facts from this section. For each fact output a JSON object with these fields:
+- fact_type: one of ${FACT_TYPES.join(', ')}
+- subject: the primary entity (model name, method name, system name, etc.)
+- predicate: a short verb phrase (achieves, outperforms, requires, assumes, proposes, uses, ...)
+- object: what the subject does/has/achieves (metric value, baseline name, dataset name, ...)
+- value: numeric value if any (e.g. "0.87")
+- unit: unit if any (e.g. "%", "ms", "F1")
+- context: conditions under which this holds (e.g. "on FORCE 2020 dataset", "with 5-fold CV")
+- evidence_text: exact quote from the section (≤400 characters) that supports this fact
+- confidence: 0.0–1.0 reflecting how clearly stated this fact is
+
+Return ONLY a valid JSON array of fact objects. No explanation, no markdown. Empty array [] if no facts found.`;
+}
+
+// ── LLM response parser ───────────────────────────────────────────────────────
+function parseFacts(raw, sectionName) {
+  if (!raw || typeof raw !== 'string') return [];
+  const trimmed = raw.trim();
+  // Strip possible markdown code fences
+  const jsonStr = trimmed.startsWith('```')
+    ? trimmed.replace(/^```[^\n]*\n?/, '').replace(/\n?```$/, '')
+    : trimmed;
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed)) return [];
+    return parsed
+      .filter(f => f && typeof f === 'object' && f.fact_type && f.evidence_text)
+      .map(f => ({
+        fact_type:         String(f.fact_type || 'claim'),
+        subject:           f.subject   ? String(f.subject).slice(0, 200)   : null,
+        predicate:         f.predicate ? String(f.predicate).slice(0, 100) : null,
+        object:            f.object    ? String(f.object).slice(0, 300)    : null,
+        value:             f.value     ? String(f.value).slice(0, 50)      : null,
+        unit:              f.unit      ? String(f.unit).slice(0, 20)       : null,
+        context:           f.context   ? String(f.context).slice(0, 300)   : null,
+        evidence_text:     String(f.evidence_text || '').slice(0, 400),
+        section:           sectionName,
+        confidence:        typeof f.confidence === 'number'
+                             ? Math.min(1, Math.max(0, f.confidence))
+                             : 0.7,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+// ── DB write helpers ──────────────────────────────────────────────────────────
+
+// Valid fact_type values matching the paper_facts CHECK constraint
+const VALID_FACT_TYPES = new Set([
+  'problem','method','claim','assumption',
+  'dataset','metric','result','baseline',
+  'limitation','future_work','contradiction_note',
+]);
+
+/**
+ * Idempotent batch insert of facts into paper_facts.
+ *
+ * Deduplication: ID is a deterministic sha256 of (doc_source_id, evidence_text, section)
+ * so INSERT OR IGNORE correctly skips duplicates on re-run.
+ *
+ * fact_type is validated against the schema CHECK enum before insert;
+ * invalid values fall back to 'claim' to avoid crashing the batch transaction.
+ */
+function writeFacts(db, docSourceId, facts) {
+  if (facts.length === 0) return;
+  const insert = db.prepare(`
+    INSERT OR IGNORE INTO paper_facts
+      (id, doc_source_id, fact_type, subject, predicate, object,
+       value, unit, context, evidence_text, section,
+       extraction_source, confidence)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'pdf_llm_section', ?)
+  `);
+  const tx = db.prepare('BEGIN');
+  const commit = db.prepare('COMMIT');
+  const rollback = db.prepare('ROLLBACK');
+  tx.run();
+  try {
+    for (const f of facts) {
+      // FLAG-7 fix: validate fact_type against enum, fallback to 'claim'
+      const factType = VALID_FACT_TYPES.has(f.fact_type) ? f.fact_type : 'claim';
+      // FLAG-8 fix: deterministic ID — sha256 of (docSourceId, section, evidence_text)
+      const idSeed = `${docSourceId}:${f.section || ''}:${f.evidence_text || ''}`;
+      const id = 'pf_' + crypto.createHash('sha256').update(idSeed).digest('hex').slice(0, 16);
+      insert.run(
+        id, docSourceId, factType,
+        f.subject, f.predicate, f.object,
+        f.value, f.unit, f.context,
+        f.evidence_text, f.section, f.confidence,
+      );
+    }
+    commit.run();
+  } catch (err) {
+    try { rollback.run(); } catch { /* ignore */ }
+    throw err;
+  }
+}
+
+// Simple entity_type inference from fact fields
+const ENTITY_HINTS = {
+  dataset:     /\b(dataset|corpus|benchmark|collection)\b/i,
+  metric:      /\b(accuracy|f1|precision|recall|auc|mse|rmse|bleu|rouge|map|ndcg)\b/i,
+  method_family: /\b(transformer|cnn|rnn|lstm|gru|bert|gpt|attention|svm|xgboost|random.?forest)\b/i,
+  problem:     /\b(classification|regression|detection|segmentation|prediction|recognition)\b/i,
+};
+
+function inferEntityType(text) {
+  if (!text) return 'concept';
+  for (const [type, re] of Object.entries(ENTITY_HINTS)) {
+    if (re.test(text)) return type;
+  }
+  return 'concept';
+}
+
+/**
+ * Register unique entities inferred from subject/object fields.
+ * INSERT OR IGNORE — safe to call multiple times.
+ */
+function registerEntities(db, facts) {
+  const seen = new Set();
+  const candidates = [];
+  for (const f of facts) {
+    for (const field of [f.subject, f.object]) {
+      if (field && field.length >= 2 && field.length <= 100 && !seen.has(field)) {
+        seen.add(field);
+        candidates.push(field);
+      }
+    }
+  }
+  if (candidates.length === 0) return;
+
+  const insert = db.prepare(`
+    INSERT OR IGNORE INTO research_entities (id, entity_type, name)
+    VALUES (?, ?, ?)
+  `);
+  const tx = db.prepare('BEGIN');
+  const commit = db.prepare('COMMIT');
+  const rollback = db.prepare('ROLLBACK');
+  tx.run();
+  try {
+    for (const name of candidates) {
+      const id = 'ent_' + crypto.randomBytes(6).toString('hex');
+      const entity_type = inferEntityType(name);
+      insert.run(id, entity_type, name);
+    }
+    commit.run();
+  } catch (err) {
+    try { rollback.run(); } catch { /* ignore */ }
+    throw err;
+  }
+}
+
+// ── Main extraction entry point ───────────────────────────────────────────────
+
+/**
+ * Extract structured facts from paper sections using per-section LLM calls.
+ * Writes results to paper_facts and research_entities tables.
+ *
+ * @param {object} db - DatabaseSync instance
+ * @param {{ id: number, title: string, slug: string }} docSource
+ * @param {{ abstract, introduction, method, experiments, results,
+ *           discussion, conclusion, _fallback: boolean }} sections
+ * @param {{ callHaiku: Function, buildDistillEnv: Function }} providers
+ * @param {{ concurrency?: number }} opts
+ * @returns {Promise<object[]>} all facts written to DB
+ */
+async function extractPaperFacts(db, docSource, sections, providers, { concurrency = 3 } = {}) {
+  const { callHaiku, buildDistillEnv } = providers;
+  const title = docSource.title || docSource.slug;
+
+  // Build one task per non-empty section (skip references, skip tiny sections)
+  const SKIP_SECTIONS = new Set(['references', '_fallback']);
+  const MIN_SECTION_LEN = 100;
+
+  const tasks = Object.entries(sections)
+    .filter(([key, text]) =>
+      !SKIP_SECTIONS.has(key) &&
+      typeof text === 'string' &&
+      text.trim().length >= MIN_SECTION_LEN
+    )
+    .map(([sectionName, sectionText]) => async () => {
+      const prompt = buildSectionFactPrompt(sectionName, sectionText, title);
+      let raw;
+      try {
+        const env = buildDistillEnv();
+        raw = await callHaiku(prompt, env, 60000, { model: 'sonnet' });
+      } catch {
+        return [];
+      }
+      return parseFacts(raw, sectionName);
+    });
+
+  if (tasks.length === 0) return [];
+
+  // Run with concurrency limit — LLM calls are all OUTSIDE any DB transaction
+  const sectionResults = await withConcurrency(tasks, concurrency);
+  const allFacts = sectionResults.flat().filter(f => f && !f.error);
+
+  if (allFacts.length === 0) return [];
+
+  // Write to DB in one shot (after all LLM calls complete)
+  writeFacts(db, docSource.id, allFacts);
+  registerEntities(db, allFacts);
+
+  return allFacts;
+}
+
+// ── Tier 1 wiki prompt builder ────────────────────────────────────────────────
+
+/**
+ * Build a prompt for generating a Tier 1 wiki page from extracted facts.
+ * The page uses a fixed 7-section structure for downstream synthesis.
+ *
+ * @param {string} title
+ * @param {object[]} facts - from paper_facts table
+ * @returns {string}
+ */
+function buildTier1Prompt(title, facts) {
+  // Group facts by type for structured rendering
+  const byType = {};
+  for (const f of facts) {
+    if (!byType[f.fact_type]) byType[f.fact_type] = [];
+    byType[f.fact_type].push(f);
+  }
+
+  function renderFacts(types) {
+    return types
+      .flatMap(t => byType[t] || [])
+      .slice(0, 12)
+      .map(f => {
+        const parts = [f.subject, f.predicate, f.object].filter(Boolean).join(' ');
+        const ctx = f.context ? ` (${f.context})` : '';
+        const ev = f.evidence_text ? `\n  Evidence: "${f.evidence_text}"` : '';
+        return `- ${parts}${ctx}${ev}`;
+      })
+      .join('\n');
+  }
+
+  const problemFacts  = renderFacts(['problem', 'assumption']);
+  const methodFacts   = renderFacts(['method', 'claim']);
+  const resultFacts   = renderFacts(['result', 'metric', 'baseline']);
+  const datasetFacts  = renderFacts(['dataset']);
+  const limitFacts    = renderFacts(['limitation', 'future_work']);
+  const allFactCount  = facts.length;
+
+  return `You are writing a Tier 1 wiki page for an academic paper knowledge base.
+
+Paper: ${title}
+Total extracted facts: ${allFactCount}
+
+Extracted evidence:
+
+## Problems / Assumptions
+${problemFacts || '(none extracted)'}
+
+## Methods / Claims
+${methodFacts || '(none extracted)'}
+
+## Results / Metrics / Baselines
+${resultFacts || '(none extracted)'}
+
+## Datasets
+${datasetFacts || '(none extracted)'}
+
+## Limitations
+${limitFacts || '(none extracted)'}
+
+Write a wiki page with EXACTLY these seven sections in order:
+## Summary
+## Problem Addressed
+## Method
+## Key Results
+## Datasets Used
+## Limitations
+## Relation to This Project
+
+Rules:
+- Ground every claim in the extracted evidence above
+- Include specific numbers, model names, and dataset names when available
+- "Relation to This Project" should note methodological connections and potential challenges — leave placeholder text "[To be filled by paper-reader-lab]" if unknown
+- Use [[wikilink]] syntax for concepts that deserve their own pages
+- 300–600 words total
+- Respond with only the wiki page content`;
+}
+
+module.exports = { extractPaperFacts, writeFacts, registerEntities, buildTier1Prompt };