hippo-memory 1.70.0 → 1.71.0

package/dist/hooks/shared.js

@@ -21,11 +21,13 @@ export function homeDir() {
 export function codexHomeDir(home = homeDir(), env = processEnv()) {
     return env.CODEX_HOME || path.join(home, '.codex');
 }
-/** Copilot's config folder: $COPILOT_HOME, else ~/.copilot under os.homedir(), as the Copilot apps resolve it (a HOME that differs from the profile must not move it). */
+/** Copilot's config folder: $COPILOT_HOME, else ~/.copilot under os.homedir(), as the
+ * Copilot apps resolve it (a HOME that differs from the profile must not move it). */
 export function copilotHomeDir(home = os.homedir(), env = processEnv()) {
     return env.COPILOT_HOME || path.join(home, '.copilot');
 }
-/** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
+/** Claude Code's config folder, where it reads settings.json: $CLAUDE_CONFIG_DIR when set and non-empty, else
+ * ~/.claude under os.homedir(), as Claude Code does (a HOME that differs from the profile must not move it). */
 export function claudeConfigDir(home = os.homedir(), env = processEnv()) {
     return env.CLAUDE_CONFIG_DIR || path.join(home, '.claude');
 }
@@ -53,20 +55,12 @@ export function isCopilotPresent(home = os.homedir()) {
 }
 /** Codex hashes each hook and skips new or changed ones until the user reviews them in `/hooks`, so the reminder says what they would trust. */
 export const CODEX_TRUST_LINE = "The per-prompt hook sends your pinned memories plus up to 5 that match the prompt. Codex runs hippo's hooks only after you trust them once in `/hooks`.";
-/**
- * Default log path consumed by `hippo last-sleep`. Shared fallback when
- * a caller doesn't pass --path explicitly.
- */
+/** Default log path consumed by `hippo last-sleep` when a caller passes no --path. */
 export function defaultSleepLogPath() {
     return path.join(homeDir(), '.hippo', 'logs', 'last-sleep.log');
 }
-/**
- * Diagnostic-only log path for `hippo pre-compact`. Deliberately separate
- * from the SessionEnd sleep log: `hippo last-sleep` truncates that file on
- * every SessionStart, which would wipe pre-compact lines before anyone
- * could read them. Nothing consumes this file programmatically — it exists
- * for manual troubleshooting only. Overridden by `--log-file`.
- */
+/** Diagnostic-only log path for `hippo pre-compact`, kept apart from the SessionEnd sleep log because `hippo last-sleep` truncates that one every SessionStart.
+ * Nothing reads it programmatically; overridden by `--log-file`. */
 export function defaultPreCompactLogPath() {
     return path.join(homeDir(), '.hippo', 'logs', 'pre-compact.log');
 }
@@ -74,21 +68,36 @@ export function ensureDir(dir) {
     if (!fs.existsSync(dir))
         fs.mkdirSync(dir, { recursive: true });
 }
-/**
- * Detect which AI coding tools are installed based on config directory presence.
- * Used by `hippo setup` to decide which JSON-hook installs to run.
- */
+/** Detect which AI coding tools are installed from config directory presence; `hippo setup` uses it to pick JSON-hook installs. */
 export function detectInstalledTools() {
     const home = homeDir();
     const exists = (...parts) => fs.existsSync(path.join(home, ...parts));
     const claudeDir = claudeConfigDir();
     return [
         { name: 'claude-code', configDir: claudeDir, detected: fs.existsSync(claudeDir), kind: 'json-hook' },
-        { name: 'opencode', configDir: '~/.config/opencode', detected: exists('.config', 'opencode'), kind: 'plugin', notes: 'installs a TS plugin at ~/.config/opencode/plugins/hippo.ts' },
+        {
+            name: 'opencode',
+            configDir: '~/.config/opencode',
+            detected: exists('.config', 'opencode'),
+            kind: 'plugin',
+            notes: 'installs a TS plugin at ~/.config/opencode/plugins/hippo.ts'
+        },
         { name: 'openclaw', configDir: '~/.openclaw', detected: exists('.openclaw'), kind: 'plugin', notes: 'install via `openclaw plugins install hippo-memory`' },
-        { name: 'codex', configDir: '~/.codex', detected: isCodexPresent(home), kind: 'wrapper', notes: 'memory hooks in hooks.json, and wraps the detected codex launcher for session-end consolidation' },
+        {
+            name: 'codex',
+            configDir: '~/.codex',
+            detected: isCodexPresent(home),
+            kind: 'wrapper',
+            notes: 'memory hooks in hooks.json, and wraps the detected codex launcher for session-end consolidation'
+        },
         { name: 'copilot', configDir: copilotHomeDir(), detected: isCopilotPresent(), kind: 'json-hook', notes: 'hooks in hooks/hippo.json, the MCP server in mcp-config.json and a block in copilot-instructions.md; for VS Code, the server in each User mcp.json and prompts/hippo.instructions.md' },
-        { name: 'cursor', configDir: '~/.cursor', detected: exists('.cursor'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
+        {
+            name: 'cursor',
+            configDir: '~/.cursor',
+            detected: exists('.cursor'),
+            kind: 'markdown-instruction',
+            notes: 'no hook API - patches AGENTS.md in the project'
+        },
         { name: 'pi', configDir: '~/.pi', detected: exists('.pi'), kind: 'markdown-instruction', notes: 'no hook API - patches AGENTS.md in the project' },
     ];
 }

package/dist/importers/core.d.ts

@@ -1,21 +1,12 @@
-/**
- * Memory importers for Hippo.
- * Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown.
- */
+/** Memory importers for Hippo.
+ *  Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown. */
 import { MemoryEntry } from '../core/memory.js';
 export interface ImportResult {
     total: number;
     imported: number;
     skipped: number;
-    /** AT1: refused by the rejection-value guard — kept distinct from
-     *  `skipped` (dedup) so a tombstoned value is distinguishable from a
-     *  plain duplicate in import summaries (plan §3 containment, round-2 low).
-     *  AT1 P2 fix (codex, published-surface compat): optional, not required —
-     *  `ImportResult` is re-exported from the package root (index.ts), and a
-     *  required field breaks any existing consumer constructing the pre-AT1
-     *  shape. Every producer in this file still always sets a real number;
-     *  `?? 0` at read sites (this file's own accumulation, cli.ts's summary
-     *  prints) tolerates a caller-supplied object that omits it. */
+    /** Entries refused by the rejection-value guard, kept apart from `skipped` (dedup) so a tombstoned value is distinguishable in summaries.
+     *  Optional because `ImportResult` is exported from the package root and a required field breaks existing consumers; read sites use `?? 0`. */
     rejected?: number;
     /** K1 vault import: rows archived this run (changed + source-deleted). In a
      *  dryRun this is the would-be count (a true deletion-sync preview). */
@@ -29,33 +20,17 @@ export interface ImportOptions {
     global?: boolean;
     extraTags?: string[];
     hippoRoot: string;
-    /**
-     * L9: tenant scope for the dedup read. When provided AND `global` is
-     * false, the dedup check only considers this tenant's existing entries.
-     * Ignored when `global: true` (global writes are host-wide by definition).
-     * Undefined preserves pre-1.12.1 host-wide dedup behaviour.
-     */
+    /** Tenant scope for the dedup read: when set and `global` is false, only this tenant's entries count.
+     *  Ignored when `global: true` (host-wide); undefined means host-wide dedup. */
     tenantId?: string;
-    /**
-     * K1 vault import only. Logical vault name used in the `vault:<name>` tag and
-     * the `artifactRef='vault:<name>:<relpath>'` key. REQUIRED by importVault: it
-     * is the identity key for the destructive source-deletion sync, so it must be
-     * set explicitly rather than inferred from the folder basename (two vaults
-     * sharing a basename would collide and clobber each other). importVault throws
-     * if it is missing or blank. Optional in this shared type only because the
-     * other importers ignore it. Operator-supplied, so the loader query LIKE-escapes
-     * it (`escapeLike` in src/util/escape.ts).
-     */
+    /** K1 vault import only: logical vault name for the `vault:<name>` tag and `artifactRef` key. REQUIRED by importVault (throws if missing or blank),
+     *  because it keys the destructive deletion sync and two vaults sharing a basename would clobber each other. LIKE-escaped by the loader. */
     name?: string;
-    /**
-     * K1 vault import only. Memory scope stamped on every imported note. Defaults
-     * to null (unscoped) when unset.
-     */
+    /** K1 vault import only. Memory scope stamped on every imported note. Defaults
+     *  to null (unscoped) when unset. */
     scope?: string;
 }
-/**
- * Given an array of raw text chunks, deduplicate against existing memories,
- * create MemoryEntry objects, write them (unless dry-run), and return a result.
- */
+/** Given an array of raw text chunks, deduplicate against existing memories,
+ *  create MemoryEntry objects, write them (unless dry-run), and return a result. */
 export declare function importEntries(chunks: string[], source: string, tags: string[], options: ImportOptions): ImportResult;
 //# sourceMappingURL=core.d.ts.map

package/dist/importers/core.js

@@ -1,25 +1,19 @@
-/**
- * Memory importers for Hippo.
- * Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown.
- */
+/** Memory importers for Hippo.
+ *  Imports memories from ChatGPT, Claude, Cursor, generic files, and structured markdown. */
+import { DEFAULT_TENANT_ID } from '../util/env.js';
 import { createMemory, Layer } from '../core/memory.js';
 import { writeEntry } from '../store/entry-writes.js';
 import { loadAllEntries } from '../store/entry-reads.js';
 import { duplicateKey, storedTextKeys } from '../util/same-text.js';
-import { getGlobalRoot, initGlobal } from '../sharing/shared.js';
+import { getGlobalRoot, initGlobal } from '../sharing/global-store.js';
 import { withRequestStoresSync } from '../db/request-stores.js';
 import { RejectedValueError } from '../store/rejection.js';
 import { rejectionGuardRefuses } from '../store/rejected-values.js';
 import { loadConfig } from '../core/config.js';
 import { vetSecrets } from '../util/secret-detect.js';
 import { log } from '../util/log.js';
-// ---------------------------------------------------------------------------
-// Shared core: dedup + write
-// ---------------------------------------------------------------------------
-/**
- * Given an array of raw text chunks, deduplicate against existing memories,
- * create MemoryEntry objects, write them (unless dry-run), and return a result.
- */
+/** Given an array of raw text chunks, deduplicate against existing memories,
+ *  create MemoryEntry objects, write them (unless dry-run), and return a result. */
 export function importEntries(chunks, source, tags, options) {
     const { targetRoot, keys } = openImportTarget(options);
     const allTags = [...new Set([...tags, ...(options.extraTags ?? [])])];
@@ -87,17 +81,8 @@ function prepareImportChunk(raw, allTags) {
     return { chunk: trimmed.slice(0, 1000), wasRedacted };
 }
 function createImportEntry(chunk, source, allTags, options, baseHalfLifeDays) {
-    // A3: kind defaults to 'distilled'. ChatGPT/Claude/Cursor exports are curated
-    // user pastes, not raw transcripts from a system of record, so distilled is
-    // correct here. E1.3 (Slack ingestion) shipped 2026-04-29 in src/connectors/slack/
-    // and sets kind: 'raw' + routes deletions through archiveRawMemory() — these
-    // importers stay 'distilled' per the original reasoning. See MEMORY_ENVELOPE.md.
-    // L9: the dedup read above is scoped by options.tenantId — the WRITE
-    // must match, or scoped-dedup-passes-then-default-tenant-write breaks
-    // the per-tenant contract. Mirror the dedup-read guard: global=true
-    // → host-wide write to global store (tenantId irrelevant, createMemory
-    // defaults to 'default'). global=false → write to the same tenant as
-    // the dedup read.
+    // kind defaults to 'distilled': these exports are curated user pastes, not raw transcripts from a system of record (see MEMORY_ENVELOPE.md).
+    // The write must use the same tenant as the scoped dedup read above: global=true writes host-wide, global=false writes to options.tenantId.
     return createMemory(chunk, {
         layer: Layer.Episodic,
         tags: allTags,
@@ -110,7 +95,7 @@ function createImportEntry(chunk, source, allTags, options, baseHalfLifeDays) {
 /** Writes the entry, or on a dry run only probes the guard; false when a rejected value refuses it. */
 function writeOrProbeImport(targetRoot, entry, options) {
     if (options.dryRun)
-        return !rejectionGuardRefuses(targetRoot, entry.tenantId ?? 'default', entry.id, entry.content);
+        return !rejectionGuardRefuses(targetRoot, entry.tenantId ?? DEFAULT_TENANT_ID, entry.id, entry.content);
     // A rejection refuses one chunk, not the whole import, so siblings still land.
     try {
         writeEntry(targetRoot, entry);
@@ -122,7 +107,4 @@ function writeOrProbeImport(targetRoot, entry, options) {
     }
     return true;
 }
-// ---------------------------------------------------------------------------
-// ChatGPT importer
-// ---------------------------------------------------------------------------
 //# sourceMappingURL=core.js.map

package/dist/importers/markdown-parse.d.ts

@@ -1,32 +1,18 @@
-/** Minimal inline frontmatter split. Recognises a leading `---\n…\n---\n`
- *  block (no YAML dep). Returns the parsed key→value map plus the body with the
- *  block removed. When no well-formed block is present, `fm` is empty and
- *  `body` is the original content. */
+/** Minimal inline frontmatter split (no YAML dep) on a leading `---\n...\n---\n` block; returns the key-value map plus the body,
+ *  or an empty `fm` and the original content when no well-formed block is present. */
 interface FrontmatterParseResult {
     fm: Record<string, string>;
     body: string;
 }
 export declare function splitMarkdownFrontmatter(raw: string): FrontmatterParseResult;
-/** Pull a frontmatter field that may be a YAML flow list (`[a, b]`), a
- *  comma-separated scalar (`a, b`), or a single token, into a string[]. Quotes
- *  and surrounding brackets are stripped; empty entries dropped. */
+/** Pull a frontmatter field that may be a YAML flow list (`[a, b]`), a comma-separated scalar, or one token into a string[];
+ *  quotes and brackets are stripped and empty entries dropped. */
 export declare function frontmatterList(value: string | undefined): string[];
-/** Parse `[[wikilinks]]` from body text. `[[target]]` and `[[target|alias]]`
- *  both yield `target` (alias dropped). Returns de-duplicated, order-preserving
- *  target strings (trimmed). Embeds (`![[…]]`) are intentionally matched too —
- *  the leading `!` is not part of the `[[…]]` capture, so an embed contributes
- *  its target as a candidate, which is the desired no-crash baseline behaviour. */
+/** Parse `[[wikilinks]]` from body text: `[[target]]` and `[[target|alias]]` both yield `target`; de-duplicated, order-preserving.
+ *  Embeds (`![[...]]`) match too, because the leading `!` is outside the capture and a candidate target is harmless. */
 export declare function parseWikilinks(body: string): string[];
-/** Recursively collect files whose name matches `match` (`*.md` by default) under `root`,
- *  as paths relative to `root` with forward-slash separators (stable artifactRef keys across OSes).
- *  Symlinks are not followed. Skips dot-directories (the default `.hippo` store,
- *  `.git`, `.obsidian`, `.trash`) AND the canonicalized Hippo store path during
- *  the walk, so re-importing a vault that CONTAINS the store never ingests its own
- *  markdown mirror files (codex R5 P1: `hippo import --vault .` after `hippo
- *  init` in the vault would otherwise self-import its mirror rows and grow on
- *  every run). The root-IS-the-store case is handled one level up in
- *  importVault (a no-op early return), NOT here: returning [] for it would feed
- *  the deletion-sync an empty scan that mass-archives every live row (codex R8). */
+/** Recursively collect files matching `match` (`*.md` default) under `root` as forward-slash relative paths; symlinks are not followed.
+ *  Skips dot-directories and the Hippo store path so a vault containing the store never imports its own mirror files; importVault handles root-IS-the-store. */
 export declare function collectMarkdownFiles(root: string, hippoRoot: string, match?: RegExp): string[];
 export {};
 //# sourceMappingURL=markdown-parse.d.ts.map

package/dist/importers/markdown-parse.js

@@ -16,9 +16,7 @@ export function splitMarkdownFrontmatter(raw) {
             continue;
         let val = kv[2].trim();
         if (val === '') {
-            // YAML block-style list: `key:` followed by indented `- item` lines
-            // (common in Obsidian/Dendron frontmatter). Collect them into a
-            // comma-joined value so frontmatterList parses them (codex P2).
+            // YAML block-style list (`key:` then indented `- item` lines, common in Obsidian/Dendron): collect into a comma-joined value for frontmatterList.
             const items = [];
             let j = i + 1;
             let item;
@@ -35,9 +33,8 @@ export function splitMarkdownFrontmatter(raw) {
     }
     return { fm, body };
 }
-/** Pull a frontmatter field that may be a YAML flow list (`[a, b]`), a
- *  comma-separated scalar (`a, b`), or a single token, into a string[]. Quotes
- *  and surrounding brackets are stripped; empty entries dropped. */
+/** Pull a frontmatter field that may be a YAML flow list (`[a, b]`), a comma-separated scalar, or one token into a string[];
+ *  quotes and brackets are stripped and empty entries dropped. */
 export function frontmatterList(value) {
     if (!value)
         return [];
@@ -49,11 +46,8 @@ export function frontmatterList(value) {
         .map((s) => s.trim().replace(/^['"]|['"]$/g, '').trim())
         .filter(Boolean);
 }
-/** Parse `[[wikilinks]]` from body text. `[[target]]` and `[[target|alias]]`
- *  both yield `target` (alias dropped). Returns de-duplicated, order-preserving
- *  target strings (trimmed). Embeds (`![[…]]`) are intentionally matched too —
- *  the leading `!` is not part of the `[[…]]` capture, so an embed contributes
- *  its target as a candidate, which is the desired no-crash baseline behaviour. */
+/** Parse `[[wikilinks]]` from body text: `[[target]]` and `[[target|alias]]` both yield `target`; de-duplicated, order-preserving.
+ *  Embeds (`![[...]]`) match too, because the leading `!` is outside the capture and a candidate target is harmless. */
 export function parseWikilinks(body) {
     const out = [];
     const seen = new Set();
@@ -71,22 +65,11 @@ export function parseWikilinks(body) {
     }
     return out;
 }
-/** Recursively collect files whose name matches `match` (`*.md` by default) under `root`,
- *  as paths relative to `root` with forward-slash separators (stable artifactRef keys across OSes).
- *  Symlinks are not followed. Skips dot-directories (the default `.hippo` store,
- *  `.git`, `.obsidian`, `.trash`) AND the canonicalized Hippo store path during
- *  the walk, so re-importing a vault that CONTAINS the store never ingests its own
- *  markdown mirror files (codex R5 P1: `hippo import --vault .` after `hippo
- *  init` in the vault would otherwise self-import its mirror rows and grow on
- *  every run). The root-IS-the-store case is handled one level up in
- *  importVault (a no-op early return), NOT here: returning [] for it would feed
- *  the deletion-sync an empty scan that mass-archives every live row (codex R8). */
+/** Recursively collect files matching `match` (`*.md` default) under `root` as forward-slash relative paths; symlinks are not followed.
+ *  Skips dot-directories and the Hippo store path so a vault containing the store never imports its own mirror files; importVault handles root-IS-the-store. */
 export function collectMarkdownFiles(root, hippoRoot, match = /\.md$/i) {
     const out = [];
-    // Canonicalize (realpath) so a non-dot HIPPO_HOME store nested in the vault is
-    // skipped even when hippoRoot is an aliased path (junction / Windows case
-    // variant); path.resolve would miss it and self-import the store's mirror
-    // files (codex R9 follow-up: same gap as the importVault guard, sibling site).
+    // Canonicalize (realpath) so a non-dot HIPPO_HOME store nested in the vault is skipped even via a junction or Windows case alias.
     const resolvedHippoRoot = realpathOrResolve(hippoRoot);
     const walk = (dir) => {
         const entries = fs.readdirSync(dir, { withFileTypes: true });

package/dist/importers/markdown.js

@@ -1,13 +1,8 @@
 import * as fs from 'fs';
 import { importEntries } from './core.js';
 const SLUG_MAX_CHARS = 50;
-// ---------------------------------------------------------------------------
-// Structured markdown importer (MEMORY.md / AGENTS.md format)
-// ---------------------------------------------------------------------------
-/**
- * Slugify a heading for use as a tag.
- * "Data Pipeline & Cache" -> "data-pipeline-cache"
- */
+/** Slugify a heading for use as a tag.
+ *  "Data Pipeline & Cache" -> "data-pipeline-cache" */
 function slugify(heading) {
     return heading
         .toLowerCase()
@@ -17,11 +12,7 @@ function slugify(heading) {
         .replace(/-+/g, '-')
         .slice(0, SLUG_MAX_CHARS);
 }
-/**
- * Parse structured markdown into {content, sectionSlug} pairs.
- * Each heading starts a new section. Bullet points / numbered items under
- * the heading become individual memories tagged with the section slug.
- */
+/** Parse structured markdown into {content, sectionSlug} pairs: each heading starts a section whose bullets or numbered items become memories. */
 function parseStructuredMarkdown(raw) {
     const results = [];
     const lines = raw.split('\n');

package/dist/importers/sources.js

@@ -13,14 +13,7 @@ function extractMemoryText(candidate) {
     }
     return '';
 }
-/**
- * Parse ChatGPT memory export file.
- * Supports:
- *   - JSON array of strings: ["memory 1", "memory 2"]
- *   - JSON array of objects: [{"content": "...", "created": "..."}]
- *   - ChatGPT export format: {"memories": [{"content": "...", "created_at": "..."}]}
- *   - Plain text: one memory per line
- */
+/** Parse a ChatGPT memory export: a JSON array of strings or `{content, created}` objects, `{"memories": [...]}`, or plain text with one memory per line. */
 function parseChatGPTFile(filePath) {
     const raw = fs.readFileSync(filePath, 'utf8').trim();
     // Try JSON first
@@ -47,14 +40,9 @@ export function importChatGPT(filePath, options) {
     const chunks = parseChatGPTFile(filePath);
     return importEntries(chunks, 'import:chatgpt', ['imported', 'chatgpt'], options);
 }
-// ---------------------------------------------------------------------------
-// Claude importer
-// ---------------------------------------------------------------------------
 const HIPPO_START = '<!-- hippo:start -->';
 const HIPPO_END = '<!-- hippo:end -->';
-/**
- * Strip the hippo hook block from markdown content.
- */
+/** Strip the hippo hook block from markdown content. */
 function stripHippoBlock(content) {
     const startIdx = content.indexOf(HIPPO_START);
     const endIdx = content.indexOf(HIPPO_END);
@@ -62,9 +50,7 @@ function stripHippoBlock(content) {
         return content;
     return content.slice(0, startIdx) + content.slice(endIdx + HIPPO_END.length);
 }
-/**
- * Split markdown into meaningful chunks (headings + bullet points).
- */
+/** Split markdown into meaningful chunks (headings + bullet points). */
 function splitMarkdown(content) {
     const chunks = [];
     const lines = content.split('\n');
@@ -119,9 +105,7 @@ function appendLine(chunks, open, line) {
     // Regular line: append to current
     return current ? current + ' ' + trimmed : trimmed;
 }
-/**
- * Parse CLAUDE.md or Claude memory.json.
- */
+/** Parse CLAUDE.md or Claude memory.json. */
 function parseClaudeFile(filePath) {
     const raw = fs.readFileSync(filePath, 'utf8');
     // JSON memory file
@@ -144,13 +128,8 @@ export function importClaude(filePath, options) {
     const chunks = parseClaudeFile(filePath);
     return importEntries(chunks, 'import:claude', ['imported', 'claude'], options);
 }
-// ---------------------------------------------------------------------------
-// Cursor importer
-// ---------------------------------------------------------------------------
-/**
- * Split cursor rules file into chunks.
- * Priority: numbered items, then bullet points, then double newlines.
- */
+/** Split cursor rules file into chunks.
+ *  Priority: numbered items, then bullet points, then double newlines. */
 function parseCursorFile(content) {
     const chunks = [];
     const lines = content.split('\n');
@@ -206,14 +185,7 @@ export function importCursor(sourcePath, options) {
     });
     return importEntries(chunks, 'import:cursor', ['imported', 'cursor'], options);
 }
-// ---------------------------------------------------------------------------
-// Generic file importer
-// ---------------------------------------------------------------------------
-/**
- * Split a generic file into chunks.
- * Markdown: split on headings and bullet points.
- * Plain text: split on double newlines or one-per-line.
- */
+/** Split a generic file into chunks: markdown on headings and bullets, plain text on double newlines or one per line. */
 function parseGenericFile(filePath) {
     const raw = fs.readFileSync(filePath, 'utf8');
     const isMarkdown = filePath.endsWith('.md') || filePath.endsWith('.mdx');

package/dist/importers/vault.d.ts

@@ -1,11 +1,5 @@
 import { type ImportResult, type ImportOptions } from './core.js';
-/**
- * Import a markdown vault FOLDER as `kind='raw'` memories.
- *
- * NOT re-entrant: idempotency rests on the in-memory `existing` Map loaded once
- * at the top. Two concurrent importVault runs over the same vault could both see
- * a note as absent and double-insert (the connector pattern relies on a single
- * sequential writer; same caveat applies here).
- */
+/** Import a markdown vault FOLDER as `kind='raw'` memories.
+ *  NOT re-entrant: idempotency rests on the in-memory `existing` Map loaded once, so two concurrent runs over one vault can double-insert. */
 export declare function importVault(folderPath: string, options: ImportOptions): ImportResult;
 //# sourceMappingURL=vault.d.ts.map