@theglitchking/semantic-memory 1.0.0

package/dist/core/embed-worker.js

@@ -0,0 +1,121 @@
+// src/core/embed-worker.ts
+import { parentPort, workerData } from "worker_threads";
+import { AutoTokenizer } from "@huggingface/transformers";
+var { modelPath, modelName, cacheDir, runtimeLabel, batchSize = 32 } = workerData;
+function meanPoolAndNormalizeMany(outputData, maskData, batchSize2, seqLen, hiddenSize) {
+  const results = [];
+  for (let b = 0; b < batchSize2; b++) {
+    const result = new Float32Array(hiddenSize);
+    let maskSum = 0;
+    for (let t = 0; t < seqLen; t++) {
+      const mask = maskData[b * seqLen + t];
+      maskSum += mask;
+      const offset = (b * seqLen + t) * hiddenSize;
+      for (let d = 0; d < hiddenSize; d++) {
+        result[d] += outputData[offset + d] * mask;
+      }
+    }
+    if (maskSum > 0) {
+      for (let d = 0; d < hiddenSize; d++) result[d] /= maskSum;
+    }
+    let norm = 0;
+    for (let d = 0; d < hiddenSize; d++) norm += result[d] * result[d];
+    norm = Math.sqrt(norm);
+    if (norm > 0) {
+      for (let d = 0; d < hiddenSize; d++) result[d] /= norm;
+    }
+    results.push(result);
+  }
+  return results;
+}
+async function init() {
+  let ort;
+  try {
+    if (runtimeLabel === "native") {
+      ort = await import("onnxruntime-node");
+    } else {
+      ort = await import("onnxruntime-web");
+    }
+  } catch {
+    ort = await import("onnxruntime-web");
+  }
+  const tokenizer = await AutoTokenizer.from_pretrained(modelName, { cache_dir: cacheDir });
+  const session = await ort.InferenceSession.create(modelPath, {
+    executionProviders: [runtimeLabel === "native" ? "cpu" : "wasm"]
+  });
+  const needsTokenTypeIds = session.inputNames.includes("token_type_ids");
+  const outputName = session.outputNames[0];
+  parentPort.postMessage({ type: "ready" });
+  parentPort.on("message", async (msg) => {
+    if (msg.type !== "embed") return;
+    try {
+      const embeddings = [];
+      let totalDone = 0;
+      for (let i = 0; i < msg.texts.length; i += batchSize) {
+        const subBatch = msg.texts.slice(i, i + batchSize);
+        const n = subBatch.length;
+        const encodings = await Promise.all(
+          subBatch.map(
+            (text) => tokenizer(text, { padding: false, truncation: true, max_length: 512, return_tensor: false })
+          )
+        );
+        const tokenized = encodings.map((enc) => ({
+          ids: Array.from(enc.input_ids.data ?? enc.input_ids),
+          mask: Array.from(enc.attention_mask.data ?? enc.attention_mask)
+        }));
+        const seqLen = Math.max(...tokenized.map((t) => t.ids.length));
+        const flatIds = new BigInt64Array(n * seqLen);
+        const flatMask = new BigInt64Array(n * seqLen);
+        const flatMaskNums = new Array(n * seqLen).fill(0);
+        for (let b = 0; b < n; b++) {
+          const { ids, mask } = tokenized[b];
+          for (let j = 0; j < ids.length; j++) {
+            flatIds[b * seqLen + j] = BigInt(ids[j]);
+            flatMask[b * seqLen + j] = BigInt(mask[j]);
+            flatMaskNums[b * seqLen + j] = mask[j];
+          }
+        }
+        const inputIds = new ort.Tensor("int64", flatIds, [n, seqLen]);
+        const attentionMask = new ort.Tensor("int64", flatMask, [n, seqLen]);
+        const feeds = { input_ids: inputIds, attention_mask: attentionMask };
+        if (needsTokenTypeIds) {
+          feeds.token_type_ids = new ort.Tensor("int64", new BigInt64Array(n * seqLen), [n, seqLen]);
+        }
+        const output = await session.run(feeds);
+        const outputTensor = output[outputName];
+        const hiddenSize = outputTensor.dims[outputTensor.dims.length - 1];
+        const batchEmbeddings = meanPoolAndNormalizeMany(
+          outputTensor.data,
+          flatMaskNums,
+          n,
+          seqLen,
+          hiddenSize
+        );
+        for (const emb of batchEmbeddings) {
+          embeddings.push(emb);
+          totalDone++;
+          parentPort.postMessage({
+            type: "progress",
+            done: totalDone,
+            total: msg.texts.length,
+            startIndex: msg.startIndex
+          });
+        }
+      }
+      parentPort.postMessage({
+        type: "result",
+        embeddings,
+        startIndex: msg.startIndex
+      });
+    } catch (err) {
+      parentPort.postMessage({
+        type: "error",
+        error: err?.message ?? String(err)
+      });
+    }
+  });
+}
+init().catch((err) => {
+  parentPort.postMessage({ type: "error", error: err?.message ?? String(err) });
+});
+//# sourceMappingURL=embed-worker.js.map

package/dist/core/embed-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/embed-worker.ts"],"sourcesContent":["import { parentPort, workerData } from \"node:worker_threads\";\nimport { AutoTokenizer } from \"@huggingface/transformers\";\n\ninterface WorkerData {\n  modelPath: string;\n  modelName: string;\n  cacheDir: string;\n  runtimeLabel: \"native\" | \"wasm\";\n  batchSize: number;\n}\n\ninterface WorkMessage {\n  type: \"embed\";\n  texts: string[];\n  startIndex: number;\n}\n\ninterface ResultMessage {\n  type: \"result\";\n  embeddings: Float32Array[];\n  startIndex: number;\n}\n\ninterface ProgressMessage {\n  type: \"progress\";\n  done: number;\n  total: number;\n  startIndex: number;\n}\n\ninterface ErrorMessage {\n  type: \"error\";\n  error: string;\n}\n\ninterface ReadyMessage {\n  type: \"ready\";\n}\n\nconst { modelPath, modelName, cacheDir, runtimeLabel, batchSize = 32 } = workerData as WorkerData;\n\nfunction meanPoolAndNormalizeMany(\n  outputData: Float32Array,\n  maskData: number[],\n  batchSize: number,\n  seqLen: number,\n  hiddenSize: number\n): Float32Array[] {\n  const results: Float32Array[] = [];\n  for (let b = 0; b < batchSize; b++) {\n    const result = new Float32Array(hiddenSize);\n    let maskSum = 0;\n    for (let t = 0; t < seqLen; t++) {\n      const mask = maskData[b * seqLen + t];\n      maskSum += mask;\n      const offset = (b * seqLen + t) * hiddenSize;\n      for (let d = 0; d < hiddenSize; d++) {\n        result[d] += (outputData as Float32Array)[offset + d] * mask;\n      }\n    }\n    if (maskSum > 0) {\n      for (let d = 0; d < hiddenSize; d++) result[d] /= maskSum;\n    }\n    let norm = 0;\n    for (let d = 0; d < hiddenSize; d++) norm += result[d] * result[d];\n    norm = Math.sqrt(norm);\n    if (norm > 0) {\n      for (let d = 0; d < hiddenSize; d++) result[d] /= norm;\n    }\n    results.push(result);\n  }\n  return results;\n}\n\nasync function init() {\n  // Resolve ONNX runtime\n  let ort: any;\n  try {\n    if (runtimeLabel === \"native\") {\n      ort = await import(\"onnxruntime-node\");\n    } else {\n      ort = await import(\"onnxruntime-web\");\n    }\n  } catch {\n    ort = await import(\"onnxruntime-web\");\n  }\n\n  // Load tokenizer and session\n  const tokenizer = await AutoTokenizer.from_pretrained(modelName, { cache_dir: cacheDir });\n  const session = await ort.InferenceSession.create(modelPath, {\n    executionProviders: [runtimeLabel === \"native\" ? \"cpu\" : \"wasm\"],\n  });\n\n  const needsTokenTypeIds = session.inputNames.includes(\"token_type_ids\");\n  const outputName = session.outputNames[0];\n\n  parentPort!.postMessage({ type: \"ready\" } as ReadyMessage);\n\n  parentPort!.on(\"message\", async (msg: WorkMessage) => {\n    if (msg.type !== \"embed\") return;\n\n    try {\n      const embeddings: Float32Array[] = [];\n      let totalDone = 0;\n\n      // Process texts in sub-batches\n      for (let i = 0; i < msg.texts.length; i += batchSize) {\n        const subBatch = msg.texts.slice(i, i + batchSize);\n        const n = subBatch.length;\n\n        // Tokenize individually to avoid ambiguous batch tokenizer output format\n        const encodings = await Promise.all(\n          subBatch.map((text: string) =>\n            tokenizer(text, { padding: false, truncation: true, max_length: 512, return_tensor: false })\n          )\n        );\n        const tokenized = encodings.map((enc: any) => ({\n          ids: Array.from(enc.input_ids.data ?? enc.input_ids) as number[],\n          mask: Array.from(enc.attention_mask.data ?? enc.attention_mask) as number[],\n        }));\n        const seqLen = Math.max(...tokenized.map((t: any) => t.ids.length));\n\n        const flatIds = new BigInt64Array(n * seqLen);\n        const flatMask = new BigInt64Array(n * seqLen);\n        const flatMaskNums = new Array<number>(n * seqLen).fill(0);\n        for (let b = 0; b < n; b++) {\n          const { ids, mask } = tokenized[b];\n          for (let j = 0; j < ids.length; j++) {\n            flatIds[b * seqLen + j] = BigInt(ids[j]);\n            flatMask[b * seqLen + j] = BigInt(mask[j]);\n            flatMaskNums[b * seqLen + j] = mask[j];\n          }\n        }\n\n        const inputIds = new ort.Tensor(\"int64\", flatIds, [n, seqLen]);\n        const attentionMask = new ort.Tensor(\"int64\", flatMask, [n, seqLen]);\n\n        const feeds: Record<string, any> = { input_ids: inputIds, attention_mask: attentionMask };\n        if (needsTokenTypeIds) {\n          feeds.token_type_ids = new ort.Tensor(\"int64\", new BigInt64Array(n * seqLen), [n, seqLen]);\n        }\n\n        const output = await session.run(feeds);\n        const outputTensor = output[outputName];\n        const hiddenSize = outputTensor.dims[outputTensor.dims.length - 1];\n\n        const batchEmbeddings = meanPoolAndNormalizeMany(\n          outputTensor.data as Float32Array,\n          flatMaskNums,\n          n,\n          seqLen,\n          hiddenSize\n        );\n\n        for (const emb of batchEmbeddings) {\n          embeddings.push(emb);\n          totalDone++;\n          parentPort!.postMessage({\n            type: \"progress\",\n            done: totalDone,\n            total: msg.texts.length,\n            startIndex: msg.startIndex,\n          } as ProgressMessage);\n        }\n      }\n\n      parentPort!.postMessage({\n        type: \"result\",\n        embeddings,\n        startIndex: msg.startIndex,\n      } as ResultMessage);\n    } catch (err: any) {\n      parentPort!.postMessage({\n        type: \"error\",\n        error: err?.message ?? String(err),\n      } as ErrorMessage);\n    }\n  });\n}\n\ninit().catch((err) => {\n  parentPort!.postMessage({ type: \"error\", error: err?.message ?? String(err) } as ErrorMessage);\n});\n"],"mappings":"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","names":["batchSize"]}

package/dist/core/index.d.ts

@@ -0,0 +1,486 @@
+import Graph from 'graphology';
+import { EventEmitter } from 'node:events';
+
+interface IndexedDocument {
+    path: string;
+    title: string;
+    content: string;
+    frontmatter: Record<string, unknown>;
+    wikilinks: string[];
+    tags: string[];
+    headers: string[];
+    chunks: string[];
+    /** ISO timestamp — prefers frontmatter last_updated/updated/date/lastmod, falls back to fs.stat mtime */
+    mtime: string;
+    loadPriority?: number;
+    status?: string;
+    tier?: string;
+    domains?: string[];
+    purpose?: string;
+    relatedDocs?: string[];
+}
+interface SearchResult {
+    path: string;
+    title: string;
+    score: number;
+    snippet: string;
+    matchedChunk?: string;
+    mtime?: string;
+    loadPriority?: number;
+    status?: string;
+    tier?: string;
+    domains?: string[];
+}
+interface GraphNode {
+    path: string;
+    title: string;
+    tags: string[];
+    linkCount: number;
+    backlinkCount: number;
+    loadPriority?: number;
+    status?: string;
+}
+interface GraphEdge {
+    source: string;
+    target: string;
+    type: "wikilink" | "tag" | "backlink";
+    weight: number;
+}
+interface GraphStats {
+    totalNodes: number;
+    totalEdges: number;
+    orphanCount: number;
+    mostConnected: Array<{
+        path: string;
+        connections: number;
+    }>;
+    density: number;
+}
+type IndexState = "empty" | "loading" | "stale" | "indexing" | "ready";
+interface VaultStats {
+    totalNotes: number;
+    totalChunks: number;
+    totalEmbeddings: number;
+    embeddingDimensions: number;
+    embeddingModel: string;
+    embeddingRuntime: "native" | "wasm" | "unknown";
+    graphNodes: number;
+    graphEdges: number;
+    indexSize: number;
+    lastIndexed: string | null;
+    indexState: IndexState;
+    indexProgress?: {
+        embedded: number;
+        total: number;
+    };
+}
+interface UpdateNoteOptions {
+    mode: "overwrite" | "append" | "prepend" | "patch-by-heading";
+    heading?: string;
+}
+interface SearchTextOptions {
+    pattern: string;
+    regex?: boolean;
+    caseSensitive?: boolean;
+    pathGlob?: string;
+    tagFilter?: string[];
+    limit?: number;
+}
+
+declare class Indexer {
+    private notesPath;
+    private processor;
+    constructor(notesPath: string);
+    indexAll(): Promise<IndexedDocument[]>;
+    /**
+     * Load parsed-doc cache from disk. Returns null if missing or unreadable.
+     * The cache is a verbatim JSON dump of a prior indexAll() result, written by
+     * saveDocsCache. Consumers (search CLI / hook path) prefer this over re-parsing
+     * 500+ markdown files; the tradeoff is that cache may be stale if the vault
+     * changed since the last reindex — same staleness window as the vector cache.
+     */
+    loadDocsCache(indexPath: string): Promise<IndexedDocument[] | null>;
+    saveDocsCache(indexPath: string, docs: IndexedDocument[]): Promise<void>;
+    indexFile(absolutePath: string, relativePath: string): Promise<IndexedDocument>;
+    /**
+     * Resolve the best available modification date for a document.
+     * Priority: last_updated → updated → date → lastmod → fs.stat mtime
+     * Accepts YYYY-MM-DD strings or full ISO timestamps.
+     */
+    private resolveMtime;
+    private extractWikilinks;
+    private extractTags;
+    private extractHeaders;
+    private nodeToText;
+    private stripMarkdown;
+    chunkText(text: string): string[];
+}
+
+type RuntimeLabel = "native" | "wasm";
+declare class Embedder {
+    private model;
+    private session;
+    private tokenizer;
+    private ort;
+    private dimensions;
+    private runtimeLabel;
+    private initialized;
+    private numWorkers;
+    private batchSize;
+    private quantized;
+    private modelPath;
+    constructor(model?: string, numWorkers?: number, batchSize?: number, quantized?: boolean);
+    init(): Promise<void>;
+    embed(text: string): Promise<Float32Array>;
+    private meanPoolAndNormalize;
+    private meanPoolAndNormalizeMany;
+    private embedSubBatch;
+    embedBatch(texts: string[], onProgress?: (embedded: number, total: number, subBatch?: Float32Array[]) => Promise<void> | void): Promise<Float32Array[]>;
+    private embedBatchParallel;
+    getDimensions(): number;
+    getModel(): string;
+    getRuntime(): RuntimeLabel;
+    saveEmbeddings(embeddings: Map<string, Float32Array>, indexPath: string): Promise<void>;
+    loadEmbeddings(indexPath: string): Promise<Map<string, Float32Array>>;
+}
+
+declare class GraphBuilder {
+    private graph;
+    constructor();
+    buildFromDocuments(documents: IndexedDocument[]): void;
+    backlinks(notePath: string): GraphNode[];
+    forwardlinks(notePath: string): GraphNode[];
+    findPath(from: string, to: string): string[] | null;
+    searchGraph(concept: string, maxDepth?: number, limit?: number): GraphNode[];
+    statistics(): GraphStats;
+    private nodeToGraphNode;
+    save(indexPath: string): Promise<void>;
+    load(indexPath: string): Promise<boolean>;
+    getGraph(): Graph;
+}
+
+interface ChunkMeta {
+    docPath: string;
+    chunkIndex: number;
+    text: string;
+}
+declare class VectorIndex {
+    private index;
+    private dimensions;
+    private chunkMeta;
+    constructor(dimensions: number);
+    build(embeddings: Float32Array[], meta: ChunkMeta[]): void;
+    search(queryEmbedding: Float32Array, k?: number): SearchResult[];
+    save(indexPath: string): Promise<void>;
+    load(indexPath: string): Promise<boolean>;
+    getChunkMeta(): ChunkMeta[];
+}
+
+declare class TextSearch {
+    private documents;
+    setDocuments(documents: IndexedDocument[]): void;
+    search(options: SearchTextOptions): SearchResult[];
+}
+
+declare class NoteCrud {
+    private notesPath;
+    constructor(notesPath: string);
+    create(relativePath: string, content: string, frontmatter?: Record<string, unknown>): Promise<string>;
+    read(relativePath: string): Promise<string>;
+    readMultiple(paths: string[]): Promise<Map<string, string>>;
+    update(relativePath: string, content: string, options: UpdateNoteOptions): Promise<void>;
+    delete(relativePath: string): Promise<void>;
+    move(fromPath: string, toPath: string): Promise<void>;
+    private updateWikilinksAfterMove;
+    private patchByHeading;
+}
+
+declare class FrontmatterManager {
+    private notesPath;
+    constructor(notesPath: string);
+    get(relativePath: string): Promise<Record<string, unknown>>;
+    update(relativePath: string, fields: Record<string, unknown>): Promise<void>;
+}
+declare class TagManager {
+    private notesPath;
+    constructor(notesPath: string);
+    list(relativePath: string): Promise<string[]>;
+    add(relativePath: string, tags: string[]): Promise<void>;
+    remove(relativePath: string, tags: string[]): Promise<void>;
+    renameVaultWide(oldTag: string, newTag: string): Promise<number>;
+}
+
+declare class Watcher extends EventEmitter {
+    private notesPath;
+    private fsWatcher;
+    private debounceMs;
+    private pendingChanges;
+    private debounceTimer;
+    private readyPromise;
+    private usePolling;
+    constructor(notesPath: string, debounceMs?: number, usePolling?: boolean);
+    start(): void;
+    ready(): Promise<void>;
+    stop(): void;
+    private enqueue;
+}
+
+interface VaultSchema {
+    version: number;
+    provenance_fields: string[];
+    status_enum: string[];
+    confidence_enum: string[];
+    severity_enum: string[];
+    types: Record<string, {
+        description?: string;
+        required: string[];
+    }>;
+    lint: {
+        missing_provenance: {
+            applies_to: string[];
+            severity: "warn" | "error";
+        };
+        stale: {
+            max_age_days: number;
+            severity: "warn" | "error";
+        };
+        schema_violations: {
+            severity: "warn" | "error";
+        };
+    };
+}
+type Severity = "warn" | "error";
+interface LintFinding {
+    path: string;
+    rule: "missing_provenance" | "stale" | "schema_violations" | "broken_links";
+    severity: Severity;
+    message: string;
+}
+declare function loadSchema(vaultPath: string): Promise<VaultSchema>;
+/**
+ * Bootstrap the schema file in a vault by writing the default if none exists.
+ * Used by the `--install-schema` CLI flag. Returns the path that was (or would be) written.
+ */
+declare function installDefaultSchema(vaultPath: string, force?: boolean): Promise<{
+    written: boolean;
+    path: string;
+}>;
+/**
+ * Validate a single note's frontmatter + content against the schema.
+ * Returns findings (possibly empty). Does NOT throw — lint never throws.
+ */
+declare function validateNote(relativePath: string, rawFileContent: string, schema: VaultSchema, opts?: {
+    todayIso?: string;
+}): LintFinding[];
+
+declare const INDEX_FILE = "INDEX.md";
+declare const INDEX_OVERFLOW_THRESHOLD = 100;
+interface IndexEntry {
+    path: string;
+    title: string;
+    summary?: string;
+}
+interface RegenResult {
+    directory: string;
+    indexPath: string;
+    entryCount: number;
+    overflowed: boolean;
+    wrote: boolean;
+}
+/**
+ * Regenerate INDEX.md for a single vault directory.
+ * Lists every *.md file in the directory (non-recursive, excluding the index itself)
+ * with its title (frontmatter or first heading) and optional summary (from frontmatter
+ * `purpose` or first non-heading paragraph).
+ */
+declare function regenDirectoryIndex(vaultPath: string, dirRel: string): Promise<RegenResult>;
+/**
+ * Regenerate indexes for every directory affected by a set of paths.
+ * Walks up the parent chain for each input so a deep change at
+ * `a/b/c/note.md` regenerates `a/b/c/INDEX.md`. Does NOT recurse further —
+ * `a/b/INDEX.md` stays as-is unless a path under `a/b/` (not `a/b/c/`)
+ * also changed.
+ */
+declare function regenIndexesForPaths(vaultPath: string, paths: string[]): Promise<RegenResult[]>;
+
+interface PatchCreate {
+    path: string;
+    content: string;
+    frontmatter?: Record<string, unknown>;
+}
+interface PatchUpdate {
+    path: string;
+    content: string;
+    mode: UpdateNoteOptions["mode"];
+    heading?: string;
+}
+interface PatchDelete {
+    path: string;
+}
+interface PatchMove {
+    from: string;
+    to: string;
+}
+interface ChangeSet {
+    creates?: PatchCreate[];
+    updates?: PatchUpdate[];
+    deletes?: PatchDelete[];
+    moves?: PatchMove[];
+}
+interface ApplyPatchOptions {
+    dryRun?: boolean;
+    validate?: boolean;
+    allowLintWarnings?: boolean;
+    /** Regenerate INDEX.md in directories touched by this patch. Default: true. */
+    regenIndexes?: boolean;
+}
+interface AppliedOp {
+    op: "create" | "update" | "delete" | "move";
+    path: string;
+}
+interface ApplyPatchResult {
+    ok: boolean;
+    applied: AppliedOp[];
+    rolledBack: AppliedOp[];
+    lint: LintFinding[];
+    errors: string[];
+    /** Index files regenerated as a side-effect. Empty if regenIndexes=false or dry-run. */
+    indexes_regenerated?: RegenResult[];
+}
+/**
+ * Atomic multi-note patch with rollback. Applies creates → updates → moves → deletes
+ * in that order. If any op fails, all successful ops before it are reverted in reverse.
+ *
+ * In dry-run mode, nothing is written; the result describes what would have happened,
+ * including lint findings on the proposed state.
+ */
+declare function applyPatch(notesPath: string, changeset: ChangeSet, options?: ApplyPatchOptions): Promise<ApplyPatchResult>;
+
+interface IngestSource {
+    /** Identifier of the source — URL, filesystem path, DOI, ISBN, etc. */
+    source_uri: string;
+    /** Human-readable title for the source-note's frontmatter */
+    source_title: string;
+    /** One of the schema types; typically "source" */
+    source_type?: string;
+    /** Path under the vault to write the source-note. Defaults to `sources/<slug>.md`. */
+    source_path?: string;
+    /** Free-form body for the source-note (summary, abstract, your notes on it) */
+    source_summary?: string;
+    /** Tags for the source-note */
+    source_tags?: string[];
+}
+interface IngestUnit {
+    /** Path under the vault where this extracted note should live */
+    path: string;
+    /** Note title — if absent, derived from basename */
+    title?: string;
+    /** Note body — markdown */
+    content: string;
+    /** Schema type. Default: "note". */
+    type?: string;
+    /** Additional wikilink-style derived_from targets beyond the source-note */
+    extra_derived_from?: string[];
+    /** Additional free-form frontmatter fields */
+    extra_frontmatter?: Record<string, unknown>;
+    /** Per-unit confidence override */
+    confidence?: string;
+}
+interface IngestInput {
+    source: IngestSource;
+    units: IngestUnit[];
+    /** If true, the existing source-note is updated if present; else an error is raised */
+    allow_existing_source?: boolean;
+}
+interface IngestPreview {
+    changeset: ChangeSet;
+    sourcePath: string;
+    unitPaths: string[];
+}
+/**
+ * Build a ChangeSet for ingesting a source into the vault.
+ *
+ * Shape: one create for the source-note (type=source) + one create per unit,
+ * each stamped with `derived_from: [<source-path>]` so lint.missing_provenance
+ * is satisfied automatically and the graph reflects the provenance edge.
+ *
+ * Intentionally does NOT touch the filesystem — callers route the result
+ * through applyPatch for atomicity, validation, and rollback.
+ */
+declare function buildIngestChangeSet(input: IngestInput): IngestPreview;
+
+interface LogEventInput {
+    kind: string;
+    summary: string;
+    payload?: Record<string, unknown>;
+    ts?: string;
+}
+interface LogEntry {
+    ts: string;
+    kind: string;
+    summary: string;
+    payload?: Record<string, unknown>;
+}
+interface LogQueryOptions {
+    kind?: string;
+    after?: string;
+    before?: string;
+    limit?: number;
+}
+declare function logEvent(vaultPath: string, input: LogEventInput): Promise<LogEntry>;
+declare function logQuery(vaultPath: string, opts?: LogQueryOptions): Promise<LogEntry[]>;
+
+interface SynthesizeNoteInput {
+    topic: string;
+    answer: string;
+    suggested_path: string;
+    type?: string;
+    sources?: string[];
+    derived_from?: string[];
+    related_notes?: string[];
+    status?: string;
+    confidence?: string;
+    decision_maker?: string;
+    decided_on?: string;
+    severity?: string;
+    extra_frontmatter?: Record<string, unknown>;
+}
+interface SynthesizePreview {
+    changeset: ChangeSet;
+    path: string;
+    title: string;
+}
+/**
+ * Convert a query answer + provenance into a ChangeSet that can be fed to applyPatch.
+ * The shaped note includes provenance frontmatter and auto-inserts [[wikilinks]] for
+ * any related_notes that appear as bare titles in the body.
+ *
+ * Does NOT write to disk — always returns a ChangeSet. Callers pass it to applyPatch.
+ */
+declare function buildSynthesizeChangeSet(input: SynthesizeNoteInput): SynthesizePreview;
+
+interface LintReport {
+    schemaPath: string;
+    findings: LintFinding[];
+    byRule: {
+        schema_violations: LintFinding[];
+        missing_provenance: LintFinding[];
+        stale: LintFinding[];
+        broken_links: LintFinding[];
+    };
+    counts: {
+        errors: number;
+        warnings: number;
+        filesLinted: number;
+    };
+}
+declare function lintVault(notesPath: string, opts?: {
+    pathGlob?: string;
+    schemaOverride?: VaultSchema;
+    todayIso?: string;
+}): Promise<LintReport>;
+declare function formatLintReport(report: LintReport, opts?: {
+    rule?: keyof LintReport["byRule"];
+}): string;
+
+export { type ApplyPatchOptions, type ApplyPatchResult, type ChangeSet, Embedder, FrontmatterManager, GraphBuilder, type GraphEdge, type GraphNode, INDEX_FILE, INDEX_OVERFLOW_THRESHOLD, type IndexEntry, type IndexedDocument, Indexer, type IngestInput, type IngestPreview, type IngestSource, type IngestUnit, type LintFinding, type LintReport, type LogEntry, type LogEventInput, type LogQueryOptions, NoteCrud, type RegenResult, type SearchResult, type Severity, type SynthesizeNoteInput, TagManager, TextSearch, type VaultSchema, type VaultStats, VectorIndex, Watcher, applyPatch, buildIngestChangeSet, buildSynthesizeChangeSet, formatLintReport, installDefaultSchema, lintVault, loadSchema, logEvent, logQuery, regenDirectoryIndex, regenIndexesForPaths, validateNote };

package/dist/core/index.js

@@ -0,0 +1,62 @@
+import {
+  FrontmatterManager,
+  INDEX_FILE,
+  INDEX_OVERFLOW_THRESHOLD,
+  NoteCrud,
+  TagManager,
+  Watcher,
+  applyPatch,
+  buildIngestChangeSet,
+  buildSynthesizeChangeSet,
+  regenDirectoryIndex,
+  regenIndexesForPaths
+} from "../chunk-CXTRTCIK.js";
+import {
+  Embedder,
+  GraphBuilder,
+  TextSearch,
+  VectorIndex
+} from "../chunk-25EIQWXL.js";
+import {
+  Indexer
+} from "../chunk-HODDRXJK.js";
+import {
+  logEvent,
+  logQuery
+} from "../chunk-JPQHNG3R.js";
+import {
+  formatLintReport,
+  lintVault
+} from "../chunk-CAN2GWUG.js";
+import {
+  installDefaultSchema,
+  loadSchema,
+  validateNote
+} from "../chunk-E2Z4J4MK.js";
+import "../chunk-PZ5AY32C.js";
+export {
+  Embedder,
+  FrontmatterManager,
+  GraphBuilder,
+  INDEX_FILE,
+  INDEX_OVERFLOW_THRESHOLD,
+  Indexer,
+  NoteCrud,
+  TagManager,
+  TextSearch,
+  VectorIndex,
+  Watcher,
+  applyPatch,
+  buildIngestChangeSet,
+  buildSynthesizeChangeSet,
+  formatLintReport,
+  installDefaultSchema,
+  lintVault,
+  loadSchema,
+  logEvent,
+  logQuery,
+  regenDirectoryIndex,
+  regenIndexesForPaths,
+  validateNote
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/indexer-KD6UTXZB.js

@@ -0,0 +1,8 @@
+import {
+  Indexer
+} from "./chunk-HODDRXJK.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  Indexer
+};
+//# sourceMappingURL=indexer-KD6UTXZB.js.map