WeKnora deployment source with the reviewed wiki identity, summary and recovery fixes

scripts/enable_business_wiki.cjs

@@ -0,0 +1,96 @@
+const fs = require('node:fs')
+const path = require('node:path')
+const assert = require('node:assert/strict')
+const { execFileSync } = require('node:child_process')
+
+const root = path.resolve(__dirname, '../..')
+const directory = path.join(root, 'acceptance')
+const tenant = 10059
+const businessIDs = ['16c3e59c-4bb6-41cf-ae0a-6d0941b3d032', '20b9280e-ed73-4700-8fa5-944d6ae6dd5f', 'bb86b44a-576b-4bf8-a6bf-8f1baca3a845', 'badd084b-f229-4005-8fb3-196fbe139fe0', '5d28a7e5-e00e-44a7-a0e1-c72342cdcf68', '3ae9257d-928a-4886-8101-7cfd0ed8c27c']
+const model = '404e005b-83ae-5e2e-a3b3-999f9d5cd47e'
+const origin = 'http://127.0.0.1:18080/api/v1'
+const statePath = path.join(directory, 'business-wiki-backfill.json')
+const literal = s => `'${String(s).replaceAll("'", "''")}'`
+const docker = (args, input) => execFileSync('docker', ['--context', 'colima-yawan', ...args], {input, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: 8 * 1024 * 1024})
+const sql = statement => docker(['exec', '-i', 'WeKnora-postgres', 'psql', '-U', 'postgres', '-d', 'yawan_native_acceptance_20260915', '-At', '-v', 'ON_ERROR_STOP=1'], statement).trim()
+let auth
+async function api(route, method = 'GET', body) {
+  const response = await fetch(origin + route, {method, headers: {'Content-Type': 'application/json', ...(auth ? {Authorization: `Bearer ${auth.token}`, 'X-Tenant-ID': String(tenant)} : {})}, body: body === undefined ? undefined : JSON.stringify(body), signal: AbortSignal.timeout(30000)})
+  const value = await response.json()
+  assert.ok(response.ok && value.success !== false, `${method} ${route}: HTTP ${response.status}`)
+  return value
+}
+function inventory() {
+  return JSON.parse(sql(`SELECT coalesce(json_agg(row_to_json(t)),'[]'::json) FROM (
+    SELECT k.id,k.name,k.type,k.indexing_strategy,k.wiki_config,k.embedding_model_id,
+      (SELECT count(*) FROM knowledges n WHERE n.knowledge_base_id=k.id AND n.deleted_at IS NULL) AS documents,
+      (SELECT count(*) FROM chunks c WHERE c.knowledge_base_id=k.id AND c.deleted_at IS NULL) AS chunks,
+      (SELECT count(*) FROM wiki_pages p WHERE p.knowledge_base_id=k.id AND p.deleted_at IS NULL) AS wiki_pages,
+      (SELECT count(*) FROM task_pending_ops o WHERE o.scope_id=k.id AND o.task_type='wiki:ingest') AS pending_documents,
+      (SELECT count(*) FROM task_pending_ops o WHERE o.scope_id=k.id AND o.task_type='wiki:finalize') AS pending_finalization,
+      (SELECT count(*) FROM task_dead_letters d WHERE d.scope_id=k.id AND d.task_type='wiki:ingest') AS failed_documents
+    FROM knowledge_bases k WHERE k.tenant_id=${tenant} AND k.id IN (${businessIDs.map(literal).join(',')}) AND k.deleted_at IS NULL AND k.is_temporary=false ORDER BY k.name
+  ) t;`))
+}
+async function main() {
+  const credentials = JSON.parse(fs.readFileSync(path.join(directory, 'super-admin-login.json'), 'utf8'))
+  auth = await api('/auth/login', 'POST', {username: credentials.username, password: credentials.password})
+  assert.equal(auth.user.is_system_admin, true)
+  const before = inventory()
+  assert.equal(before.length, businessIDs.length, 'All six business knowledge bases must exist')
+  let state = fs.existsSync(statePath) ? JSON.parse(fs.readFileSync(statePath, 'utf8')) : {started_at: new Date().toISOString(), tenant_id: tenant, before}
+  if (process.argv.includes('--apply')) {
+    const modelRow = sql(`SELECT count(*) FROM models WHERE id=${literal(model)} AND tenant_id=${tenant} AND deleted_at IS NULL AND type='KnowledgeQA';`)
+    assert.equal(modelRow, '1')
+    fs.writeFileSync(path.join(directory, `business-wiki-config-before-${Date.now()}.json`), JSON.stringify(before, null, 2), {mode: 0o600, flag: 'wx'})
+    for (const row of before) {
+      assert.equal(row.type, 'document', 'Only document knowledge bases are supported')
+      assert.equal(row.indexing_strategy.vector_enabled, true, 'Existing vector index is required')
+      assert.equal(row.indexing_strategy.keyword_enabled, true, 'Existing keyword index is required')
+      const kb = (await api(`/knowledge-bases/${row.id}`)).data
+      const updated = await api(`/knowledge-bases/${row.id}`, 'PUT', {name: kb.name, description: kb.description, config: {
+        chunking_config: kb.chunking_config, image_processing_config: kb.image_processing_config,
+        faq_config: kb.faq_config, auto_tag_config: kb.auto_tag_config,
+        indexing_strategy: {...kb.indexing_strategy, wiki_enabled: true},
+        wiki_config: {...kb.wiki_config, synthesis_model_id: model, extraction_granularity: 'standard', max_pages_per_ingest: 0,
+          ingest_batch_size: 1, ingest_map_parallel: 1, ingest_reduce_parallel: 1, ingest_max_inflight: 1},
+      }})
+      assert.equal(updated.data.indexing_strategy.wiki_enabled, true)
+      assert.equal(updated.data.embedding_model_id, row.embedding_model_id)
+    }
+    const ids = before.map(k => literal(k.id)).join(',')
+    // Backfill the Wiki queue without resetting document status or rebuilding RAG indexes.
+    state.enqueued = Number(sql(`WITH added AS (
+      INSERT INTO task_pending_ops (tenant_id,task_type,scope,scope_id,op,dedup_key,payload,fail_count,enqueued_at)
+      SELECT n.tenant_id,'wiki:ingest','knowledge_base',n.knowledge_base_id,'ingest',n.id,
+        jsonb_build_object('op','ingest','knowledge_id',n.id,'language','zh-CN'),0,now()
+      FROM knowledges n JOIN knowledge_bases k ON k.id=n.knowledge_base_id AND k.tenant_id=n.tenant_id
+      WHERE n.tenant_id=${tenant} AND n.knowledge_base_id IN (${ids}) AND n.deleted_at IS NULL
+        AND k.deleted_at IS NULL AND k.indexing_strategy->>'wiki_enabled'='true'
+        AND n.parse_status='completed' AND n.pending_subtasks_count=0
+        AND EXISTS (SELECT 1 FROM chunks c WHERE c.knowledge_id=n.id AND c.deleted_at IS NULL)
+        AND NOT EXISTS (SELECT 1 FROM task_pending_ops o WHERE o.tenant_id=n.tenant_id AND o.scope_id=n.knowledge_base_id AND o.task_type='wiki:ingest' AND o.dedup_key=n.id)
+        AND NOT EXISTS (SELECT 1 FROM wiki_pages p WHERE p.knowledge_base_id=n.knowledge_base_id AND p.deleted_at IS NULL AND p.source_refs @> jsonb_build_array(n.id))
+      RETURNING id
+    ) SELECT count(*) FROM added;`))
+    state.configured_at = new Date().toISOString()
+    fs.writeFileSync(statePath, JSON.stringify(state, null, 2), {mode: 0o600})
+    const scopes = before.map(k => ({tenant_id: tenant, knowledge_base_id: k.id, language: 'zh-CN'}))
+    docker(['cp', path.join(directory, 'wiki-backfill-trigger'), 'yawan-native-acceptance:/tmp/wiki-backfill-trigger'])
+    state.trigger_result = JSON.parse(docker(['exec', '-i', 'yawan-native-acceptance', '/tmp/wiki-backfill-trigger'], JSON.stringify(scopes)))
+  }
+  state.checked_at = new Date().toISOString()
+  state.current = inventory()
+  for (const prior of state.before) {
+    const current = state.current.find(k => k.id === prior.id)
+    assert.equal(current.documents, prior.documents)
+    assert.equal(current.chunks, prior.chunks)
+    assert.equal(current.embedding_model_id, prior.embedding_model_id)
+  }
+  state.rag_preserved = true
+  state.all_wiki_enabled = state.current.every(k => k.indexing_strategy.wiki_enabled && k.indexing_strategy.vector_enabled && k.indexing_strategy.keyword_enabled)
+  if (process.argv.includes('--apply')) assert.equal(state.all_wiki_enabled, true)
+  fs.writeFileSync(statePath, JSON.stringify(state, null, 2), {mode: 0o600})
+  console.log(JSON.stringify({checked_at: state.checked_at, all_wiki_enabled: state.all_wiki_enabled, rag_preserved: true, enqueued: state.enqueued, knowledge_bases: state.current.map(k => ({name: k.name,documents: k.documents,chunks: k.chunks,wiki_pages: k.wiki_pages,pending_documents:k.pending_documents,pending_finalization:k.pending_finalization,failed_documents:k.failed_documents}))}))
+}
+main().catch(error => {console.error(error.message); process.exitCode = 1})