@equationalapplications/expo-llm-wiki 2.2.0 → 2.4.0

package/README.md

@@ -1,273 +1,69 @@
-# expo-llm-wiki
+# @equationalapplications/expo-llm-wiki
 
-[![GitHub Tag](https://img.shields.io/github/v/tag/equationalapplications/expo-llm-wiki?label=github%20tag)](https://github.com/equationalapplications/expo-llm-wiki/tags)
-[![npm version](https://img.shields.io/npm/v/%40equationalapplications%2Fexpo-llm-wiki?label=npm)](https://www.npmjs.com/package/@equationalapplications/expo-llm-wiki)
-[![npm downloads](https://img.shields.io/npm/dm/%40equationalapplications%2Fexpo-llm-wiki?label=downloads)](https://www.npmjs.com/package/@equationalapplications/expo-llm-wiki)
-[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+Expo/React Native adapter for @equationalapplications/core-llm-wiki, powered by `expo-sqlite`.
 
-Offline-first, SQLite-backed memory for LLM apps built with Expo. Handles FTS5 search, episodic event logging, background fact extraction, and memory healing — bring your own LLM.
+## Features
 
-## Key Principles
-
-- **Bring Your Own Inference (BYOI):** Provide one `generateText` function. The package owns prompt construction, JSON parsing, and database writes.
-- **Namespace Safe:** All tables are prefixed (default: `llm_wiki_`) — no collisions with your existing database.
-- **Multi-Entity:** Multiple independent "brains" in one database via `entityId`.
-- **Offline First:** Reads are fully local via SQLite FTS5, typically under 50ms.
-- **Morphological Matching:** Porter stemming enables recall across word forms — queries for `running` match facts about `run`, `runs`, etc., without manual synonym configuration.
-- **Full Unicode Support:** UTF-8 and UTF-16 (including surrogate pairs for emoji) are fully supported. Chunks are split safely at sentence boundaries; surrogate pairs are never fragmented.
-
-## How It Works
-
-```mermaid
-flowchart LR
-    subgraph API
-        direction TB
-        write["write(event)"]
-        ingest["ingestDocument()"]
-        librarian["runLibrarian()"]
-        heal["runHeal()"]
-    end
-
-    subgraph SQLite
-        direction TB
-        events[(events)]
-        entries[("entries\n(facts)")]
-        tasks[(tasks)]
-    end
-
-    LLM["LLMProvider\n.generateText()"]
-
-    read["read(entityId, query)"]
-    FTS5(["FTS5 search"])
-    Bundle(["MemoryBundle\nfacts · tasks · events"])
-
-    write --> events
-    events -. "≥ threshold" .-> librarian
-    librarian --> LLM
-    heal --> LLM
-    ingest --> LLM
-    LLM --> entries
-    LLM --> tasks
-
-    read --> FTS5
-    FTS5 --> entries
-    entries --> Bundle
-    tasks --> Bundle
-    events --> Bundle
-```
+- **Expo-ready** — Pre-configured for React Native + Expo
+- **Built on `expo-sqlite`** — Stable, well-supported SQLite driver
+- **React hooks** — `WikiProvider`, `useMemoryRead`, and all other hooks are re-exported directly from `@equationalapplications/expo-llm-wiki`
 
 ## Installation
 
-In your Expo project:
-
 ```bash
 npx expo install expo-sqlite
-npm install expo-llm-wiki
+npm install @equationalapplications/expo-llm-wiki
 ```
 
-Use `npx expo install` for `expo-sqlite` so Expo's version resolver picks the correct native build for your SDK version.
-
-## Setup
+## Usage
 
 ```typescript
-import { createWiki } from 'expo-llm-wiki';
-import * as SQLite from 'expo-sqlite';
+import { createWiki } from '@equationalapplications/expo-llm-wiki';
+import { openDatabaseSync } from 'expo-sqlite';
 
-const db = await SQLite.openDatabaseAsync('my-app.db');
+const db = openDatabaseSync('wiki.db');
 
 const wiki = createWiki(db, {
   llmProvider: {
     generateText: async ({ systemPrompt, userPrompt }) => {
-      // Connect to OpenAI, Gemini, a local model, etc.
-      // Must return a raw string (JSON, optionally in a markdown code fence).
-      const response = await openai.chat.completions.create({
-        model: 'gpt-4o-mini',
-        messages: [
-          { role: 'system', content: systemPrompt },
-          { role: 'user', content: userPrompt },
-        ],
-      });
-      return response.choices[0].message.content ?? '{}';
+      // Your LLM call — must return the model output as a string
+      return 'Model output';
     },
   },
-  config: {
-    tablePrefix: 'llm_wiki_',       // optional, default: 'llm_wiki_'
-    maxFtsResults: 10,              // optional, default: 10
-    autoLibrarianThreshold: 20,     // optional, default: 20
-    maxChunkLength: 6000,           // optional, default: 6000 (char count, not bytes)
-    chunkOverlap: 400,              // optional, default: 400 (overlap between chunks in characters)
-    chunkConcurrency: 1,            // optional, default: 1 (parallel LLM calls per ingestDocument)
-  },
 });
 
-// Create tables and FTS5 indexes (call once on app startup)
+// Initialize tables (call once on app startup)
 await wiki.setup();
-```
-
-## Core API
-
-### Read
 
-FTS5 full-text search over facts, plus open tasks and recent events:
-
-```typescript
-const { facts, tasks, events } = await wiki.read('entity-123', 'weekend plans');
-// facts: WikiFact[]   — matched by FTS5, ranked by confidence + access count
-// tasks: WikiTask[]   — pending and in-progress only
-// events: WikiEvent[] — 10 most recent, ascending
+// Use wiki instance
+await wiki.write('user-123', { event_type: 'observation', summary: '...' });
 ```
 
-Pass an empty string to skip FTS and return the most recently updated facts.
+## With React
 
-### Write
-
-Log an episodic event. Automatically triggers the librarian pass once enough events accumulate:
+`@equationalapplications/expo-llm-wiki` re-exports all hooks and `WikiProvider` from `@equationalapplications/react-llm-wiki`:
 
 ```typescript
-await wiki.write('entity-123', {
-  event_type: 'observation',
-  summary: 'User mentioned they love hiking on weekends.',
-});
-// event_type: 'observation' | 'decision' | 'action' | 'outcome'
-```
-
-### Ingest Document
-
-Extract facts from a document (chunked internally). Idempotent — re-calling with the same `sourceRef` replaces the prior extraction. Documents are automatically chunked at sentence boundaries; if a sentence exceeds `maxChunkLength`, it is hard-split.
-
-```typescript
-const result = await wiki.ingestDocument('entity-123', {
-  // sourceRef is normalized: only [A-Za-z0-9._\- ] are kept, all other characters
-  // (including `/`) are stripped. Use underscores or dots as path separators to
-  // avoid accidental collisions (e.g. 'docs_preferences.md' not 'docs/preferences.md').
-  sourceRef: 'preferences.md',        // stable identifier
-  sourceHash: sha256(content),        // for change detection
-  documentChunk: content,
-  maxChunkLength: 12000,              // optional, character count
-  chunkOverlap: 400,                  // optional, overlap in characters
-  chunkConcurrency: 1,                // optional, parallel LLM calls per ingest (default: 1)
-});
-// result: { truncated: boolean; chunks: number }
-// truncated: true if at least one hard-split was required (no sentence boundary)
-// chunks: number of LLM calls made
-```
-
-### Background Maintenance
-
-```typescript
-// Consolidate recent events into durable facts (auto-triggered by write, or call manually)
-await wiki.runLibrarian('entity-123');
+import { WikiProvider } from '@equationalapplications/expo-llm-wiki';
 
-// Resolve contradictions, downgrade stale claims, remove obsolete facts
-await wiki.runHeal('entity-123');
+<WikiProvider wiki={wiki}>
+  <MyApp />
+</WikiProvider>
 ```
 
-### Forget
+Then use hooks in components:
 
 ```typescript
-const result = await wiki.forget('entity-123', { entryId: 'fact_abc' });    // single fact
-// result: { deleted: { entries: number; tasks: number } }
-
-await wiki.forget('entity-123', { taskId: 'task_xyz' });     // single task
-// sourceRef is normalized the same way as in ingestDocument (slashes stripped)
-await wiki.forget('entity-123', { sourceRef: 'x.md' }); // all facts from a document
-await wiki.forget('entity-123', { clearAll: true });          // wipe entity
-```
-
-Throws `Error` if `sourceRef` or `sourceHash` is provided but invalid. Soft-deletes are idempotent — calling again with the same parameters returns `{ deleted: { entries: 0; tasks: 0 } }`.
-
----
-
-## React / Expo Component API
-
-Import from `expo-llm-wiki/react`. This entry point is separate so non-React consumers do not transitively import React.
-
-### Provider
-
-Wrap once at app root (or any subtree that needs memory access):
+import { useMemoryRead } from '@equationalapplications/expo-llm-wiki';
 
-```typescript
-import { WikiProvider } from 'expo-llm-wiki/react';
-import { createWiki } from 'expo-llm-wiki';
-
-const wiki = createWiki(db, { llmProvider });
-
-export default function App() {
-  return (
-    <WikiProvider wiki={wiki}>
-      <YourApp />
-    </WikiProvider>
-  );
-}
-```
-
-### `useMemoryRead(entityId, query)`
-
-Reactive read. Fetches on mount and whenever `entityId` or `query` changes. In-flight results always land before a queued re-fetch starts — results are never silently discarded.
-
-```typescript
-const { data, isPending, error, refetch } = useMemoryRead('entity-123', 'weekend plans');
-// data: MemoryBundle | null
-```
-
-### `useWikiWrite()`
-
-```typescript
-const { execute, isPending, error } = useWikiWrite();
-
-await execute('entity-123', {
-  event_type: 'observation',
-  summary: 'User mentioned they love hiking.',
-});
-```
-
-### `useWikiMaintenance()`
-
-Shared `isPending` — true if either operation is in-flight:
-
-```typescript
-const { runLibrarian, runHeal, isPending, error } = useWikiMaintenance();
-
-await runLibrarian('entity-123');
-await runHeal('entity-123');
-```
-
-### `useWikiIngest()`
-
-```typescript
-const { execute, lastResult, isPending, error } = useWikiIngest();
-// lastResult: { truncated: boolean; chunks: number } | null
-
-const result = await execute('entity-123', {
-  sourceRef: 'preferences.md',  // slashes are stripped by normalizeSourceRef
-  sourceHash: sha256(content),
-  documentChunk: content,
-});
-// result.truncated — true if any hard-splits were required
-// result.chunks   — number of LLM calls made
-```
-
-### `useWikiForget()`
-
-```typescript
-const { execute, lastResult, isPending, error } = useWikiForget();
-// lastResult: { deleted: { entries: number; tasks: number } } | null
-
-const result = await execute('entity-123', { entryId: 'fact_abc' });
-// result.deleted.entries — rows soft-deleted
-```
-
-All mutation hooks follow the same pattern (`TResult` is specific per hook):
-
-```typescript
-{
-  execute: (...args) => Promise<TResult>;
-  lastResult: TResult | null;  // result of the last successful call; null before first call or after an error
-  isPending: boolean;
-  error: Error | null;         // cleared on the next execute call
+export function UserProfile({ userId }: { userId: string }) {
+  const { data, isPending } = useMemoryRead(userId, 'preferences');
+  
+  if (isPending) return <Text>Loading...</Text>;
+  return <Text>{data?.facts.map(f => f.title).join(', ')}</Text>;
 }
 ```
 
----
+## License
 
-Made with ❤️ by Equational Applications LLC. [https://equationalapplications.com/](https://equationalapplications.com/)
+MIT

package/dist/chunk-6DVBBIYR.mjs

@@ -0,0 +1,24 @@
+// src/adapter.ts
+function createExpoAdapter(db) {
+  return {
+    execAsync: (sql) => db.execAsync(sql),
+    runAsync: async (sql, params = []) => {
+      const result = await db.runAsync(sql, params);
+      return { changes: result.changes, lastInsertRowId: result.lastInsertRowId };
+    },
+    getAllAsync: (sql, params = []) => db.getAllAsync(sql, params),
+    getFirstAsync: (sql, params = []) => db.getFirstAsync(sql, params),
+    withTransactionAsync: (fn) => {
+      let captured;
+      return db.withTransactionAsync(() => fn().then((v) => {
+        captured = v;
+      })).then(() => captured);
+    },
+    closeAsync: () => db.closeAsync()
+  };
+}
+
+export {
+  createExpoAdapter
+};
+//# sourceMappingURL=chunk-6DVBBIYR.mjs.map

package/dist/chunk-6DVBBIYR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/adapter.ts"],"sourcesContent":["import type * as SQLite from 'expo-sqlite';\nimport type { SQLiteAdapter } from '@equationalapplications/core-llm-wiki';\n\nexport function createExpoAdapter(db: SQLite.SQLiteDatabase): SQLiteAdapter {\n  return {\n    execAsync: (sql) => db.execAsync(sql),\n    runAsync: async (sql, params = []) => {\n      const result = await db.runAsync(sql, params as any[]);\n      return { changes: result.changes, lastInsertRowId: result.lastInsertRowId };\n    },\n    getAllAsync: (sql, params = []) => db.getAllAsync(sql, params as any[]),\n    getFirstAsync: (sql, params = []) => db.getFirstAsync(sql, params as any[]),\n    withTransactionAsync: (fn) => {\n      // expo-sqlite only accepts () => Promise<void>; capture the result to satisfy the generic interface\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let captured: any;\n      return db.withTransactionAsync(() => fn().then(v => { captured = v; })).then(() => captured);\n    },\n    closeAsync: () => db.closeAsync(),\n  };\n}\n"],"mappings":";AAGO,SAAS,kBAAkB,IAA0C;AAC1E,SAAO;AAAA,IACL,WAAW,CAAC,QAAQ,GAAG,UAAU,GAAG;AAAA,IACpC,UAAU,OAAO,KAAK,SAAS,CAAC,MAAM;AACpC,YAAM,SAAS,MAAM,GAAG,SAAS,KAAK,MAAe;AACrD,aAAO,EAAE,SAAS,OAAO,SAAS,iBAAiB,OAAO,gBAAgB;AAAA,IAC5E;AAAA,IACA,aAAa,CAAC,KAAK,SAAS,CAAC,MAAM,GAAG,YAAY,KAAK,MAAe;AAAA,IACtE,eAAe,CAAC,KAAK,SAAS,CAAC,MAAM,GAAG,cAAc,KAAK,MAAe;AAAA,IAC1E,sBAAsB,CAAC,OAAO;AAG5B,UAAI;AACJ,aAAO,GAAG,qBAAqB,MAAM,GAAG,EAAE,KAAK,OAAK;AAAE,mBAAW;AAAA,MAAG,CAAC,CAAC,EAAE,KAAK,MAAM,QAAQ;AAAA,IAC7F;AAAA,IACA,YAAY,MAAM,GAAG,WAAW;AAAA,EAClC;AACF;","names":[]}

package/dist/factory.d.mts

@@ -0,0 +1,12 @@
+import * as SQLite from 'expo-sqlite';
+import { WikiOptions, WikiMemory } from '@equationalapplications/core-llm-wiki';
+
+/**
+ * Create a WikiMemory instance from an expo-sqlite SQLiteDatabase.
+ * This factory is exported as a separate subpath (`@equationalapplications/expo-llm-wiki/factory`)
+ * so that callers can obtain `createWiki` without loading the React hooks
+ * that `@equationalapplications/expo-llm-wiki`'s main entry re-exports from `@equationalapplications/react-llm-wiki`.
+ */
+declare function createWiki(db: SQLite.SQLiteDatabase, options: WikiOptions): WikiMemory;
+
+export { createWiki };

package/dist/factory.d.ts

@@ -0,0 +1,12 @@
+import * as SQLite from 'expo-sqlite';
+import { WikiOptions, WikiMemory } from '@equationalapplications/core-llm-wiki';
+
+/**
+ * Create a WikiMemory instance from an expo-sqlite SQLiteDatabase.
+ * This factory is exported as a separate subpath (`@equationalapplications/expo-llm-wiki/factory`)
+ * so that callers can obtain `createWiki` without loading the React hooks
+ * that `@equationalapplications/expo-llm-wiki`'s main entry re-exports from `@equationalapplications/react-llm-wiki`.
+ */
+declare function createWiki(db: SQLite.SQLiteDatabase, options: WikiOptions): WikiMemory;
+
+export { createWiki };

package/dist/factory.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/factory.ts
+var factory_exports = {};
+__export(factory_exports, {
+  createWiki: () => createWiki
+});
+module.exports = __toCommonJS(factory_exports);
+var import_core_llm_wiki = require("@equationalapplications/core-llm-wiki");
+
+// src/adapter.ts
+function createExpoAdapter(db) {
+  return {
+    execAsync: (sql) => db.execAsync(sql),
+    runAsync: async (sql, params = []) => {
+      const result = await db.runAsync(sql, params);
+      return { changes: result.changes, lastInsertRowId: result.lastInsertRowId };
+    },
+    getAllAsync: (sql, params = []) => db.getAllAsync(sql, params),
+    getFirstAsync: (sql, params = []) => db.getFirstAsync(sql, params),
+    withTransactionAsync: (fn) => {
+      let captured;
+      return db.withTransactionAsync(() => fn().then((v) => {
+        captured = v;
+      })).then(() => captured);
+    },
+    closeAsync: () => db.closeAsync()
+  };
+}
+
+// src/factory.ts
+function createWiki(db, options) {
+  return new import_core_llm_wiki.WikiMemory(createExpoAdapter(db), options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWiki
+});
+//# sourceMappingURL=factory.js.map

package/dist/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/factory.ts","../src/adapter.ts"],"sourcesContent":["import type * as SQLite from 'expo-sqlite';\nimport { WikiMemory, type WikiOptions } from '@equationalapplications/core-llm-wiki';\nimport { createExpoAdapter } from './adapter';\n\n/**\n * Create a WikiMemory instance from an expo-sqlite SQLiteDatabase.\n * This factory is exported as a separate subpath (`@equationalapplications/expo-llm-wiki/factory`)\n * so that callers can obtain `createWiki` without loading the React hooks\n * that `@equationalapplications/expo-llm-wiki`'s main entry re-exports from `@equationalapplications/react-llm-wiki`.\n */\nexport function createWiki(db: SQLite.SQLiteDatabase, options: WikiOptions): WikiMemory {\n  return new WikiMemory(createExpoAdapter(db), options);\n}\n","import type * as SQLite from 'expo-sqlite';\nimport type { SQLiteAdapter } from '@equationalapplications/core-llm-wiki';\n\nexport function createExpoAdapter(db: SQLite.SQLiteDatabase): SQLiteAdapter {\n  return {\n    execAsync: (sql) => db.execAsync(sql),\n    runAsync: async (sql, params = []) => {\n      const result = await db.runAsync(sql, params as any[]);\n      return { changes: result.changes, lastInsertRowId: result.lastInsertRowId };\n    },\n    getAllAsync: (sql, params = []) => db.getAllAsync(sql, params as any[]),\n    getFirstAsync: (sql, params = []) => db.getFirstAsync(sql, params as any[]),\n    withTransactionAsync: (fn) => {\n      // expo-sqlite only accepts () => Promise<void>; capture the result to satisfy the generic interface\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      let captured: any;\n      return db.withTransactionAsync(() => fn().then(v => { captured = v; })).then(() => captured);\n    },\n    closeAsync: () => db.closeAsync(),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,2BAA6C;;;ACEtC,SAAS,kBAAkB,IAA0C;AAC1E,SAAO;AAAA,IACL,WAAW,CAAC,QAAQ,GAAG,UAAU,GAAG;AAAA,IACpC,UAAU,OAAO,KAAK,SAAS,CAAC,MAAM;AACpC,YAAM,SAAS,MAAM,GAAG,SAAS,KAAK,MAAe;AACrD,aAAO,EAAE,SAAS,OAAO,SAAS,iBAAiB,OAAO,gBAAgB;AAAA,IAC5E;AAAA,IACA,aAAa,CAAC,KAAK,SAAS,CAAC,MAAM,GAAG,YAAY,KAAK,MAAe;AAAA,IACtE,eAAe,CAAC,KAAK,SAAS,CAAC,MAAM,GAAG,cAAc,KAAK,MAAe;AAAA,IAC1E,sBAAsB,CAAC,OAAO;AAG5B,UAAI;AACJ,aAAO,GAAG,qBAAqB,MAAM,GAAG,EAAE,KAAK,OAAK;AAAE,mBAAW;AAAA,MAAG,CAAC,CAAC,EAAE,KAAK,MAAM,QAAQ;AAAA,IAC7F;AAAA,IACA,YAAY,MAAM,GAAG,WAAW;AAAA,EAClC;AACF;;;ADVO,SAAS,WAAW,IAA2B,SAAkC;AACtF,SAAO,IAAI,gCAAW,kBAAkB,EAAE,GAAG,OAAO;AACtD;","names":[]}

package/dist/factory.mjs

@@ -0,0 +1,13 @@
+import {
+  createExpoAdapter
+} from "./chunk-6DVBBIYR.mjs";
+
+// src/factory.ts
+import { WikiMemory } from "@equationalapplications/core-llm-wiki";
+function createWiki(db, options) {
+  return new WikiMemory(createExpoAdapter(db), options);
+}
+export {
+  createWiki
+};
+//# sourceMappingURL=factory.mjs.map

package/dist/factory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/factory.ts"],"sourcesContent":["import type * as SQLite from 'expo-sqlite';\nimport { WikiMemory, type WikiOptions } from '@equationalapplications/core-llm-wiki';\nimport { createExpoAdapter } from './adapter';\n\n/**\n * Create a WikiMemory instance from an expo-sqlite SQLiteDatabase.\n * This factory is exported as a separate subpath (`@equationalapplications/expo-llm-wiki/factory`)\n * so that callers can obtain `createWiki` without loading the React hooks\n * that `@equationalapplications/expo-llm-wiki`'s main entry re-exports from `@equationalapplications/react-llm-wiki`.\n */\nexport function createWiki(db: SQLite.SQLiteDatabase, options: WikiOptions): WikiMemory {\n  return new WikiMemory(createExpoAdapter(db), options);\n}\n"],"mappings":";;;;;AACA,SAAS,kBAAoC;AAStC,SAAS,WAAW,IAA2B,SAAkC;AACtF,SAAO,IAAI,WAAW,kBAAkB,EAAE,GAAG,OAAO;AACtD;","names":[]}

package/dist/index.d.mts

@@ -1,9 +1,8 @@
 import * as SQLite from 'expo-sqlite';
-import { M as MemoryDump, F as FormattedMemoryDump, W as WikiOptions, a as WikiMemory } from './WikiMemory-CjlQ68X0.mjs';
-export { E as EntityStatus, b as ExtractedFact, c as ExtractedTask, d as FormatContextOptions, L as LLMProvider, e as MemoryBundle, f as WikiBusyError, g as WikiCheckpoint, h as WikiConfig, i as WikiEvent, j as WikiFact, k as WikiTask } from './WikiMemory-CjlQ68X0.mjs';
-
-declare function formatMemoryDump(dump: MemoryDump): FormattedMemoryDump;
+import { WikiOptions, WikiMemory } from '@equationalapplications/core-llm-wiki';
+export * from '@equationalapplications/core-llm-wiki';
+export * from '@equationalapplications/react-llm-wiki';
 
 declare function createWiki(db: SQLite.SQLiteDatabase, options: WikiOptions): WikiMemory;
 
-export { FormattedMemoryDump, MemoryDump, WikiMemory, WikiOptions, createWiki, formatMemoryDump };
+export { createWiki };

package/dist/index.d.ts

@@ -1,9 +1,8 @@
 import * as SQLite from 'expo-sqlite';
-import { M as MemoryDump, F as FormattedMemoryDump, W as WikiOptions, a as WikiMemory } from './WikiMemory-CjlQ68X0.js';
-export { E as EntityStatus, b as ExtractedFact, c as ExtractedTask, d as FormatContextOptions, L as LLMProvider, e as MemoryBundle, f as WikiBusyError, g as WikiCheckpoint, h as WikiConfig, i as WikiEvent, j as WikiFact, k as WikiTask } from './WikiMemory-CjlQ68X0.js';
-
-declare function formatMemoryDump(dump: MemoryDump): FormattedMemoryDump;
+import { WikiOptions, WikiMemory } from '@equationalapplications/core-llm-wiki';
+export * from '@equationalapplications/core-llm-wiki';
+export * from '@equationalapplications/react-llm-wiki';
 
 declare function createWiki(db: SQLite.SQLiteDatabase, options: WikiOptions): WikiMemory;
 
-export { FormattedMemoryDump, MemoryDump, WikiMemory, WikiOptions, createWiki, formatMemoryDump };
+export { createWiki };