spine-framework 0.3.144 → 0.4.0

package/.framework/mcp/shared/db.ts

@@ -0,0 +1,477 @@
+// CIL[BEGIN stable_id="~/.framework/mcp/shared/db.ts:mcp_db:file" type="file" identity="mcp_db" parent="~/.framework/mcp/shared/db.ts"]
+// CIL[DOC-MACRO purpose="MCP admin-data proxy query builder and type resolver for the Spine framework."]
+// CIL[DOC-RESPONSIBILITY responsibility="Provides a fluent Query class that proxies Supabase-style requests to the admin-data Netlify function, plus helpers to resolve type and link type IDs."]
+// CIL[DOC-CONTEXT module="mcp" layer="shared" related_files=".framework/mcp/shared/db.ts"]
+// CIL[DOC-CONTRACT inputs="table names, filters, sort/limit options, insert/update/delete payloads" outputs="records or {data,error} shaped results" errors="Environment missing, network/HTTP errors, record not found" side_effects="Makes fetch calls to the Spine admin-data and function endpoints."]
+// CIL[DOC-MICRO logic_summary="Builds URL query parameters, applies client-side filters/sorting, handles single/maybeSingle semantics, and routes apps/embeddings tables to dedicated function endpoints." notable_decisions="admin-data does not support upsert; apps/embeddings writes are rejected; RPC only supports match_embeddings."]
+// CIL[DOC-CONFIDENCE pass="second" score="0.90" flags="none"]
+// CIL[DOC-STABILITY stability="stable"]
+
+import { randomUUID } from 'node:crypto'
+
+const SPINE_URL = process.env.SPINE_URL || process.env.URL || ''
+
+const API_KEY = process.env.SPINE_API_KEY || process.env.SPINE_FRAMEWORK_API_KEY || ''
+
+function baseUrl(): string {
+  if (!SPINE_URL) throw new Error('SPINE_URL environment variable is required')
+  return SPINE_URL.replace(/\/$/, '')
+}
+
+function headers(): Record<string, string> {
+  if (!API_KEY) throw new Error('SPINE_API_KEY environment variable is required')
+  return {
+    'Content-Type': 'application/json',
+    'X-Api-Key': API_KEY,
+    'X-Request-ID': randomUUID(),
+    'X-Source': 'spine-framework-mcp',
+  }
+}
+
+async function handleResponse<T>(res: Response): Promise<T> {
+  const body = await res.json().catch(() => ({}))
+  if (!res.ok) {
+    throw new Error(body?.error || body?.message || `request failed: ${res.status}`)
+  }
+  if (body && 'data' in body) {
+    return body.data as T
+  }
+  return body as T
+}
+
+async function fetchAdminData(
+  entity: string,
+  action: 'list' | 'get' | 'create' | 'update' | 'remove' | 'stats',
+  query: Record<string, any> = {},
+  body?: Record<string, any>
+): Promise<any> {
+  const methodMap: Record<string, string> = {
+    list: 'GET',
+    get: 'GET',
+    stats: 'GET',
+    create: 'POST',
+    update: 'PATCH',
+    remove: 'DELETE',
+  }
+  const method = methodMap[action]
+  const params: Record<string, any> = { ...query, action, entity, method }
+  const qs = new URLSearchParams(params as Record<string, string>).toString()
+  const init: RequestInit = { method, headers: headers() }
+  if (body && (action === 'create' || action === 'update')) {
+    init.body = JSON.stringify(body)
+  }
+  const res = await fetch(`${baseUrl()}/.netlify/functions/admin-data?${qs}`, init)
+  const data = await handleResponse<any>(res)
+  if (Array.isArray(data)) return data
+  return data
+}
+
+export async function fetchFunction(functionName: string, action: string, query: Record<string, any> = {}, body?: Record<string, any>): Promise<any> {
+  const method = body ? 'POST' : 'GET'
+  const params: Record<string, any> = { ...query, action, method }
+  const qs = new URLSearchParams(params as Record<string, string>).toString()
+  const init: RequestInit = { method, headers: headers() }
+  if (body) init.body = JSON.stringify(body)
+  const res = await fetch(`${baseUrl()}/.netlify/functions/${functionName}?${qs}`, init)
+  return handleResponse<any>(res)
+}
+
+type Filter = { key: string; op: string; value: any }
+
+type Sort = { field: string; ascending: boolean }
+
+class Query {
+  private table: string
+  private columns = '*'
+  private count = false
+  private head = false
+  private _single = false
+  private _maybeSingle = false
+  private filters: Filter[] = []
+  private sorts: Sort[] = []
+  private limitN?: number
+  private rangeFrom?: number
+  private rangeTo?: number
+  private insertData?: any
+  private updateData?: any
+  private deleteFlag = false
+  private selectAfterInsert = false
+
+  constructor(table: string) {
+    this.table = table
+  }
+
+  select(columns?: string, opts?: { count?: 'exact'; head?: boolean }) {
+    if (columns) this.columns = columns
+    if (opts) {
+      this.count = opts.count === 'exact'
+      this.head = !!opts.head
+    }
+    return this
+  }
+
+  eq(key: string, value: any) {
+    this.filters.push({ key, op: 'eq', value })
+    return this
+  }
+
+  filter(key: string, op: string, value: any) {
+    this.filters.push({ key, op, value })
+    return this
+  }
+
+  in(key: string, values: any[]) {
+    this.filters.push({ key, op: 'in', value: values })
+    return this
+  }
+
+  order(field: string, opts?: { ascending?: boolean }) {
+    this.sorts.push({ field, ascending: opts?.ascending !== false })
+    return this
+  }
+
+  limit(n: number) {
+    this.limitN = n
+    return this
+  }
+
+  range(from: number, to: number) {
+    this.rangeFrom = from
+    this.rangeTo = to
+    return this
+  }
+
+  ilike(key: string, value: any) {
+    this.filters.push({ key, op: 'ilike', value })
+    return this
+  }
+
+  lte(key: string, value: any) {
+    this.filters.push({ key, op: 'lte', value })
+    return this
+  }
+
+  gte(key: string, value: any) {
+    this.filters.push({ key, op: 'gte', value })
+    return this
+  }
+
+  neq(key: string, value: any) {
+    this.filters.push({ key, op: 'neq', value })
+    return this
+  }
+
+  maybeSingle() {
+    this._maybeSingle = true
+    return this
+  }
+
+  single() {
+    this._single = true
+    return this
+  }
+
+  insert(data: any) {
+    this.insertData = data
+    return this
+  }
+
+  update(data: any) {
+    this.updateData = data
+    return this
+  }
+
+  upsert(data: any) {
+    // admin-data does not support upsert; treat as create
+    this.insertData = data
+    return this
+  }
+
+  delete() {
+    this.deleteFlag = true
+    return this
+  }
+
+  contains(key: string, value: any) {
+    this.filters.push({ key, op: 'contains', value })
+    return this
+  }
+
+  then<TResult1 = any, TResult2 = never>(
+    onfulfilled?: ((value: any) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null
+  ): Promise<TResult1 | TResult2> {
+    return this.execute().then(onfulfilled, onrejected)
+  }
+
+  private async execute(): Promise<any> {
+    if (this.table === 'apps') return this.executeApps()
+    if (this.table === 'embeddings') return this.executeEmbeddings()
+    return this.executeAdminData()
+  }
+
+  private async executeApps(): Promise<any> {
+    if (this.insertData || this.updateData || this.deleteFlag) {
+      throw new Error('apps write not supported through MCP proxy')
+    }
+    const idFilter = this.filters.find(f => f.key === 'id')
+    const slugFilter = this.filters.find(f => f.key === 'slug')
+    if (this._single || this._maybeSingle || idFilter || slugFilter) {
+      const q: Record<string, any> = {}
+      if (idFilter) q.id = idFilter.value
+      else if (slugFilter) q.slug = slugFilter.value
+      try {
+        const record = await fetchFunction('apps', 'get', q)
+        if (this._single && !record) throw new Error('App not found')
+        return { data: record || null, error: null }
+      } catch (err: any) {
+        if (this._maybeSingle && (err?.message?.includes('not found') || err?.message?.includes('Not found') || err?.message?.includes('not_found'))) {
+          return { data: null, error: null }
+        }
+        return { data: null, error: err }
+      }
+    }
+    const records = await fetchFunction('apps', 'list', { include_system: 'true', include_inactive: 'true' })
+    const filtered = this.applyClientFilters(records || [])
+    const sorted = this.applyClientSort(filtered)
+    return { data: sorted, error: null }
+  }
+
+  private async executeEmbeddings(): Promise<any> {
+    if (this.insertData || this.updateData || this.deleteFlag) {
+      throw new Error('embeddings write not supported through MCP proxy')
+    }
+    const q: Record<string, any> = {}
+    const modelFilter = this.filters.find(f => f.key === 'model_id')
+    const docFilter = this.filters.find(f => f.key === 'document_id')
+    if (modelFilter) q.model_id = modelFilter.value
+    if (docFilter) q.document_id = docFilter.value
+    if (this.limitN) q.limit = this.limitN
+    if (this.rangeFrom !== undefined) q.offset = this.rangeFrom
+    const records = await fetchFunction('embeddings', 'list', q)
+    return { data: records || [], error: null }
+  }
+
+  private async executeAdminData(): Promise<any> {
+    const entity = this.table
+    const idFilter = this.filters.find(f => f.key === 'id')
+    const hasIdFilter = !!idFilter
+
+    if (this.count && this.head) {
+      try {
+        const result = await fetchAdminData(entity, 'stats', {})
+        return { data: [], count: result?.count ?? 0, error: null }
+      } catch (err: any) {
+        return { data: [], count: 0, error: err }
+      }
+    }
+
+    if (this.insertData) {
+      const record = await fetchAdminData(entity, 'create', {}, this.insertData)
+      if (this.selectAfterInsert && this.columns === 'id') {
+        return { data: record ? { id: record.id } : record, error: null }
+      }
+      return { data: record, error: null }
+    }
+
+    if (this.updateData) {
+      if (!hasIdFilter) throw new Error('update requires id filter')
+      const record = await fetchAdminData(entity, 'update', { id: idFilter.value }, this.updateData)
+      return { data: record, error: null }
+    }
+
+    if (this.deleteFlag) {
+      if (hasIdFilter) {
+        const record = await fetchAdminData(entity, 'remove', { id: idFilter.value })
+        return { data: record, error: null }
+      }
+
+      // list with any eq filters we can push, then client-filter the rest
+      const params: Record<string, any> = {}
+      for (const f of this.filters) {
+        if (f.op === 'eq') params[f.key] = f.value
+      }
+      const records = await fetchAdminData(entity, 'list', { ...params, limit: 5000 })
+      const toDelete = this.applyClientFilters(records || [], this.filters)
+      for (const record of toDelete) {
+        await fetchAdminData(entity, 'remove', { id: record.id })
+      }
+      return { data: null, error: null }
+    }
+
+    if ((this._single || this._maybeSingle) && hasIdFilter) {
+      try {
+        const record = await fetchAdminData(entity, 'get', { id: idFilter.value })
+        if (this._single && !record) throw new Error('Record not found')
+        return { data: record || null, error: null }
+      } catch (err: any) {
+        if (this._maybeSingle) return { data: null, error: null }
+        return { data: null, error: err }
+      }
+    }
+
+    const inIdFilter = this.filters.find(f => f.key === 'id' && f.op === 'in')
+    if (inIdFilter) {
+      const records: any[] = []
+      for (const id of inIdFilter.value) {
+        try {
+          const record = await fetchAdminData(entity, 'get', { id })
+          if (record) records.push(record)
+        } catch {
+          // ignore missing
+        }
+      }
+      const otherFilters = this.filters.filter(f => !(f.key === 'id' && f.op === 'in'))
+      const filtered = this.applyClientFilters(records, otherFilters)
+      return { data: filtered, error: null }
+    }
+
+    const params: Record<string, any> = {}
+    for (const f of this.filters) {
+      if (f.op === 'eq') {
+        params[f.key] = f.value
+      } else if (f.op === 'ilike') {
+        params.search = f.value.replace(/%/g, '')
+      } else {
+        // other ops are not supported by admin-data list; will client-filter later
+      }
+    }
+    if (this.rangeFrom !== undefined && this.rangeTo !== undefined) {
+      params.offset = this.rangeFrom
+      params.limit = Math.max(0, this.rangeTo - this.rangeFrom)
+    }
+    if (this.limitN !== undefined) {
+      params.limit = this.limitN
+    }
+    if (this.sorts.length > 0) {
+      params.sort_field = this.sorts[0].field
+      params.sort_direction = this.sorts[0].ascending ? 'asc' : 'desc'
+    }
+
+    const records = await fetchAdminData(entity, 'list', params)
+    const filtered = this.applyClientFilters(records || [])
+
+    if (this._single) {
+      if (filtered.length === 0) throw new Error('Record not found')
+      if (filtered.length > 1) throw new Error('Multiple records found')
+      return { data: filtered[0], error: null }
+    }
+
+    if (this._maybeSingle) {
+      return { data: filtered[0] || null, error: null }
+    }
+
+    return { data: filtered, error: null }
+  }
+
+  private applyClientFilters(records: any[], filters = this.filters): any[] {
+    return records.filter(record => {
+      for (const f of filters) {
+        const value = this.getValue(record, f.key)
+        if (f.op === 'eq' && value !== f.value) return false
+        if (f.op === 'in' && !f.value.includes(value)) return false
+        if (f.op === 'ilike' && typeof value === 'string' && !value.toLowerCase().includes(String(f.value).toLowerCase().replace(/%/g, ''))) return false
+        if (f.op === 'lte' && value > f.value) return false
+        if (f.op === 'gte' && value < f.value) return false
+        if (f.op === 'neq' && value === f.value) return false
+        if (f.op === 'contains') {
+          if (Array.isArray(value) && !value.includes(f.value)) return false
+          if (typeof value === 'string' && !value.includes(f.value)) return false
+        }
+      }
+      return true
+    })
+  }
+
+  private applyClientSort(records: any[]): any[] {
+    if (this.sorts.length === 0) return records
+    const s = this.sorts[0]
+    return [...records].sort((a, b) => {
+      const av = this.getValue(a, s.field)
+      const bv = this.getValue(b, s.field)
+      if (av < bv) return s.ascending ? -1 : 1
+      if (av > bv) return s.ascending ? 1 : -1
+      return 0
+    })
+  }
+
+  private getValue(record: any, key: string): any {
+    if (key === 'id') return record.id
+    if (key in record) return record[key]
+    if (key.startsWith('data->>')) {
+      const field = key.slice(7)
+      return record.data?.[field]
+    }
+    if (key.startsWith('data->')) {
+      const path = key.slice(6)
+      return record.data?.[path]
+    }
+    return undefined
+  }
+}
+
+export const adminDb = {
+  from(table: string) {
+    return new Query(table)
+  },
+  async rpc(name: string, params: Record<string, any> = {}): Promise<any> {
+    if (name === 'match_embeddings') {
+      const result = await fetchFunction('embeddings', 'search-similar', {}, {
+        query_embedding: params.query_embedding,
+        model_id: params.model_id || 'text-embedding-3-small',
+        limit: params.match_count || params.limit || 10,
+        threshold: params.similarity_threshold || 0.15,
+        filter_account_ids: params.filter_account_ids ?? null,
+        filter_vector_type: params.filter_vector_type ?? null,
+        filter_item_types: params.filter_item_types ?? null,
+        filter_document_ids: params.filter_document_ids ?? null,
+      })
+      const rows = Array.isArray(result) ? result : (result?.results || [])
+      return { data: rows, error: null }
+    }
+    throw new Error(`RPC not supported through MCP proxy: ${name}`)
+  },
+}
+
+export async function resolveTypeRecord(kind: string, slug: string): Promise<any> {
+  const rows = await fetchAdminData('types', 'list', { kind, slug, limit: 1 })
+  const row = rows?.[0]
+  if (!row) throw new Error(`Type not found: ${kind}/${slug}`)
+  return {
+    id: row.id,
+    slug: row.slug,
+    kind: row.kind,
+    design_schema: row.design_schema || {},
+    validation_schema: row.validation_schema || {},
+    is_active: row.is_active ?? true,
+  }
+}
+
+export async function resolveTypeId(kind: string, slug: string): Promise<string> {
+  const record = await resolveTypeRecord(kind, slug)
+  return record.id
+}
+
+export async function resolveLinkTypeId(slug: string): Promise<string> {
+  const rows = await fetchAdminData('link_types', 'list', { slug, limit: 1 })
+  const row = rows?.[0]
+  if (!row) throw new Error(`Link type not found: ${slug}`)
+  return row.id
+}
+
+export async function resolveLinkTypeIds(slugs: string[]): Promise<Record<string, string>> {
+  const ids = await Promise.all(slugs.map(resolveLinkTypeId))
+  const result: Record<string, string> = {}
+  for (let i = 0; i < slugs.length; i++) {
+    result[slugs[i]] = ids[i]
+  }
+  return result
+}
+
+// CIL[DOC-VECTOR type="context" content="purpose='MCP admin-data proxy query builder and type resolver for the Spine framework.'; No verified external callers; imports: none"]
+// CIL[DOC-VECTOR type="blast_radius" content="No direct caller data from CIL graph; local impact only"]
+// CIL[DOC-VECTOR type="configuration" content="No environment or build configuration dependencies identified"]
+// CIL[DOC-VECTOR type="constraint" content="Standard runtime; no special invariants documented"]
+// CIL[DOC-VECTOR type="implementation_pattern" content="" status="pending_human_input"]
+// CIL[DOC-VECTOR type="user_journey" content="" status="pending_human_input"]
+// CIL[END stable_id="~/.framework/mcp/shared/db.ts:mcp_db:file"]

package/.framework/mcp/shared/kb.ts

@@ -0,0 +1,118 @@
+// CIL[BEGIN stable_id="~/.framework/mcp/shared/kb.ts:module_header:module_header" type="module_header" identity="module_header" parent="~/.framework/mcp/shared/kb.ts"]
+// CIL[DOC-MACRO purpose="Shared MCP KB operation wrappers"]
+// CIL[DOC-RESPONSIBILITY responsibility="Provide thin async wrappers that route KB search/ingest/reindex/revoke/publish operations to the database fetch function"]
+// CIL[DOC-CONTEXT module=".framework/mcp/shared/kb.ts" layer="mcp" related_files=".framework/mcp/shared/db.ts"]
+// CIL[DOC-CONTRACT inputs="none at module level" outputs="named KB operation exports" errors="none at module level" side_effects="none at module level"]
+// CIL[DOC-MICRO logic_summary="Re-exports fetchFunction-bound helpers for the kb namespace" notable_decisions="[]"]
+// CIL[DOC-CONFIDENCE pass="second" score="0.90" flags="none"]
+// CIL[DOC-STABILITY stability="stable"]
+// CIL[DOC-AUDIENCE audience="mcp"]
+
+import { fetchFunction } from './db.js'
+// CIL[DOC-VECTOR type="context" content="purpose='Shared MCP KB operation wrappers'; No verified external callers; imports: .framework/mcp/shared/db.ts"]
+// CIL[DOC-VECTOR type="blast_radius" content="No direct caller data from CIL graph; local impact only"]
+// CIL[DOC-VECTOR type="configuration" content="No environment or build configuration dependencies identified"]
+// CIL[DOC-VECTOR type="constraint" content="Standard runtime; no special invariants documented"]
+// CIL[DOC-VECTOR type="implementation_pattern" content="" status="pending_human_input"]
+// CIL[DOC-VECTOR type="user_journey" content="" status="pending_human_input"]
+// CIL[END stable_id="~/.framework/mcp/shared/kb.ts:module_header:module_header"]
+
+
+// CIL[BEGIN stable_id="~/.framework/mcp/shared/kb.ts:kbsearch:function" type="function" identity="kbSearch" parent="~/.framework/mcp/shared/kb.ts"]
+// CIL[DOC-MACRO purpose="Search the knowledge base"]
+// CIL[DOC-RESPONSIBILITY responsibility="Delegate a KB search call to the database fetchFunction"]
+// CIL[DOC-CONTEXT module=".framework/mcp/shared/kb.ts" layer="mcp" related_files=".framework/mcp/shared/db.ts,.framework/mcp/shared/kb.ts"]
+// CIL[DOC-CONTRACT inputs="_ctx: any, body: Record<string, any>" outputs="Promise<any>" errors="propagates fetchFunction errors" side_effects="queries the KB search index"]
+// CIL[DOC-MICRO logic_summary="Calls fetchFunction with the kb namespace, search action, empty static context, and the provided body" notable_decisions="[]"]
+// CIL[DOC-CONFIDENCE pass="second" score="0.90" flags="none"]
+// CIL[DOC-STABILITY stability="stable"]
+export async function kbSearch(_ctx: any, body: Record<string, any>): Promise<any> {
+  return fetchFunction('kb', 'search', {}, body)
+}
+// CIL[DOC-VECTOR type="context" content="purpose='Search the knowledge base'; No verified external callers; imports: .framework/mcp/shared/db.ts"]
+// CIL[DOC-VECTOR type="blast_radius" content="No direct caller data from CIL graph; local impact only"]
+// CIL[DOC-VECTOR type="configuration" content="No environment or build configuration dependencies identified"]
+// CIL[DOC-VECTOR type="constraint" content="Standard runtime; no special invariants documented"]
+// CIL[DOC-VECTOR type="implementation_pattern" content="" status="pending_human_input"]
+// CIL[DOC-VECTOR type="user_journey" content="" status="pending_human_input"]
+// CIL[END stable_id="~/.framework/mcp/shared/kb.ts:kbsearch:function"]
+
+
+// CIL[BEGIN stable_id="~/.framework/mcp/shared/kb.ts:kbingest:function" type="function" identity="kbIngest" parent="~/.framework/mcp/shared/kb.ts"]
+// CIL[DOC-MACRO purpose="Ingest content into the knowledge base"]
+// CIL[DOC-RESPONSIBILITY responsibility="Delegate a KB ingest call to the database fetchFunction"]
+// CIL[DOC-CONTEXT module=".framework/mcp/shared/kb.ts" layer="mcp" related_files=".framework/mcp/shared/db.ts,.framework/mcp/shared/kb.ts"]
+// CIL[DOC-CONTRACT inputs="_ctx: any, body: Record<string, any>" outputs="Promise<any>" errors="propagates fetchFunction errors" side_effects="adds or updates KB records"]
+// CIL[DOC-MICRO logic_summary="Calls fetchFunction with the kb namespace, ingest action, empty static context, and the provided body" notable_decisions="[]"]
+// CIL[DOC-CONFIDENCE pass="second" score="0.90" flags="none"]
+// CIL[DOC-STABILITY stability="stable"]
+export async function kbIngest(_ctx: any, body: Record<string, any>): Promise<any> {
+  return fetchFunction('kb', 'ingest', {}, body)
+}
+// CIL[DOC-VECTOR type="context" content="purpose='Ingest content into the knowledge base'; No verified external callers; imports: .framework/mcp/shared/db.ts"]
+// CIL[DOC-VECTOR type="blast_radius" content="No direct caller data from CIL graph; local impact only"]
+// CIL[DOC-VECTOR type="configuration" content="No environment or build configuration dependencies identified"]
+// CIL[DOC-VECTOR type="constraint" content="Standard runtime; no special invariants documented"]
+// CIL[DOC-VECTOR type="implementation_pattern" content="" status="pending_human_input"]
+// CIL[DOC-VECTOR type="user_journey" content="" status="pending_human_input"]
+// CIL[END stable_id="~/.framework/mcp/shared/kb.ts:kbingest:function"]
+
+
+// CIL[BEGIN stable_id="~/.framework/mcp/shared/kb.ts:kbreindex:function" type="function" identity="kbReindex" parent="~/.framework/mcp/shared/kb.ts"]
+// CIL[DOC-MACRO purpose="Reindex the knowledge base"]
+// CIL[DOC-RESPONSIBILITY responsibility="Delegate a KB reindex call to the database fetchFunction"]
+// CIL[DOC-CONTEXT module=".framework/mcp/shared/kb.ts" layer="mcp" related_files=".framework/mcp/shared/db.ts,.framework/mcp/shared/kb.ts"]
+// CIL[DOC-CONTRACT inputs="_ctx: any, body: Record<string, any>" outputs="Promise<any>" errors="propagates fetchFunction errors" side_effects="rebuilds the KB index"]
+// CIL[DOC-MICRO logic_summary="Calls fetchFunction with the kb namespace, reindex action, empty static context, and the provided body" notable_decisions="[]"]
+// CIL[DOC-CONFIDENCE pass="second" score="0.90" flags="none"]
+// CIL[DOC-STABILITY stability="stable"]
+export async function kbReindex(_ctx: any, body: Record<string, any>): Promise<any> {
+  return fetchFunction('kb', 'reindex', {}, body)
+}
+// CIL[DOC-VECTOR type="context" content="purpose='Reindex the knowledge base'; No verified external callers; imports: .framework/mcp/shared/db.ts"]
+// CIL[DOC-VECTOR type="blast_radius" content="No direct caller data from CIL graph; local impact only"]
+// CIL[DOC-VECTOR type="configuration" content="No environment or build configuration dependencies identified"]
+// CIL[DOC-VECTOR type="constraint" content="Standard runtime; no special invariants documented"]
+// CIL[DOC-VECTOR type="implementation_pattern" content="" status="pending_human_input"]
+// CIL[DOC-VECTOR type="user_journey" content="" status="pending_human_input"]
+// CIL[END stable_id="~/.framework/mcp/shared/kb.ts:kbreindex:function"]
+
+
+// CIL[BEGIN stable_id="~/.framework/mcp/shared/kb.ts:kbrevoke:function" type="function" identity="kbRevoke" parent="~/.framework/mcp/shared/kb.ts"]
+// CIL[DOC-MACRO purpose="Revoke a knowledge base record"]
+// CIL[DOC-RESPONSIBILITY responsibility="Delegate a KB revoke call to the database fetchFunction"]
+// CIL[DOC-CONTEXT module=".framework/mcp/shared/kb.ts" layer="mcp" related_files=".framework/mcp/shared/db.ts,.framework/mcp/shared/kb.ts"]
+// CIL[DOC-CONTRACT inputs="_ctx: any, body: Record<string, any>" outputs="Promise<any>" errors="propagates fetchFunction errors" side_effects="removes or invalidates the specified KB record"]
+// CIL[DOC-MICRO logic_summary="Calls fetchFunction with the kb namespace, revoke action, empty static context, and the provided body" notable_decisions="[]"]
+// CIL[DOC-CONFIDENCE pass="second" score="0.90" flags="none"]
+// CIL[DOC-STABILITY stability="stable"]
+export async function kbRevoke(_ctx: any, body: Record<string, any>): Promise<any> {
+  return fetchFunction('kb', 'revoke', {}, body)
+}
+// CIL[DOC-VECTOR type="context" content="purpose='Revoke a knowledge base record'; No verified external callers; imports: .framework/mcp/shared/db.ts"]
+// CIL[DOC-VECTOR type="blast_radius" content="No direct caller data from CIL graph; local impact only"]
+// CIL[DOC-VECTOR type="configuration" content="No environment or build configuration dependencies identified"]
+// CIL[DOC-VECTOR type="constraint" content="Standard runtime; no special invariants documented"]
+// CIL[DOC-VECTOR type="implementation_pattern" content="" status="pending_human_input"]
+// CIL[DOC-VECTOR type="user_journey" content="" status="pending_human_input"]
+// CIL[END stable_id="~/.framework/mcp/shared/kb.ts:kbrevoke:function"]
+
+
+// CIL[BEGIN stable_id="~/.framework/mcp/shared/kb.ts:kbpublish:function" type="function" identity="kbPublish" parent="~/.framework/mcp/shared/kb.ts"]
+// CIL[DOC-MACRO purpose="Publish a knowledge base record"]
+// CIL[DOC-RESPONSIBILITY responsibility="Delegate a KB publish call to the database fetchFunction"]
+// CIL[DOC-CONTEXT module=".framework/mcp/shared/kb.ts" layer="mcp" related_files=".framework/mcp/shared/db.ts,.framework/mcp/shared/kb.ts"]
+// CIL[DOC-CONTRACT inputs="_ctx: any, body: Record<string, any>" outputs="Promise<any>" errors="propagates fetchFunction errors" side_effects="publishes the specified KB record"]
+// CIL[DOC-MICRO logic_summary="Calls fetchFunction with the kb namespace, publish action, empty static context, and the provided body" notable_decisions="[]"]
+// CIL[DOC-CONFIDENCE pass="second" score="0.90" flags="none"]
+// CIL[DOC-STABILITY stability="stable"]
+export async function kbPublish(_ctx: any, body: Record<string, any>): Promise<any> {
+  return fetchFunction('kb', 'publish', {}, body)
+}
+// CIL[DOC-VECTOR type="context" content="purpose='Publish a knowledge base record'; No verified external callers; imports: .framework/mcp/shared/db.ts"]
+// CIL[DOC-VECTOR type="blast_radius" content="No direct caller data from CIL graph; local impact only"]
+// CIL[DOC-VECTOR type="configuration" content="No environment or build configuration dependencies identified"]
+// CIL[DOC-VECTOR type="constraint" content="Standard runtime; no special invariants documented"]
+// CIL[DOC-VECTOR type="implementation_pattern" content="" status="pending_human_input"]
+// CIL[DOC-VECTOR type="user_journey" content="" status="pending_human_input"]
+// CIL[END stable_id="~/.framework/mcp/shared/kb.ts:kbpublish:function"]