hippo-memory 1.69.0 → 1.71.0

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

@@ -1,41 +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 parseFrontmatter(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. */
+export declare function splitMarkdownFrontmatter(raw: string): FrontmatterParseResult;
+/** 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[];
-/** Canonicalize a path for the self-store comparison: dereference symlinks /
- *  junctions and normalize case (Windows) via the OS realpath, so a junction or
- *  a case-variant path to the store is still recognized as self-store (codex R9
- *  P2: path.resolve does neither, so an aliased store path slipped past the
- *  guard and triggered the mass-archive). Falls back to path.resolve when the
- *  path does not exist yet - an uninitialized store or a typo'd vault path
- *  cannot be a live self-store, and a non-existent vault folder fails later in
- *  the walk (readdirSync) before deletion-sync can archive anything. */
-export declare function realpathOrResolve(p: string): string;
 export {};
 //# sourceMappingURL=markdown-parse.d.ts.map

package/dist/importers/markdown-parse.js

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { log } from '../log.js';
-export function parseFrontmatter(raw) {
+import { realpathOrResolve } from '../util/real-path.js';
+export function splitMarkdownFrontmatter(raw) {
     // Must start with `---` on its own line. Accept CRLF or LF.
     const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
     if (!m)
@@ -16,9 +16,7 @@ export function parseFrontmatter(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 parseFrontmatter(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 });
@@ -112,21 +95,4 @@ export function collectMarkdownFiles(root, hippoRoot, match = /\.md$/i) {
     out.sort();
     return out;
 }
-/** Canonicalize a path for the self-store comparison: dereference symlinks /
- *  junctions and normalize case (Windows) via the OS realpath, so a junction or
- *  a case-variant path to the store is still recognized as self-store (codex R9
- *  P2: path.resolve does neither, so an aliased store path slipped past the
- *  guard and triggered the mass-archive). Falls back to path.resolve when the
- *  path does not exist yet - an uninitialized store or a typo'd vault path
- *  cannot be a live self-store, and a non-existent vault folder fails later in
- *  the walk (readdirSync) before deletion-sync can archive anything. */
-export function realpathOrResolve(p) {
-    try {
-        return fs.realpathSync.native(p);
-    }
-    catch (err) {
-        log.debug(`import: realpath fell back to resolve for ${p}: ${err instanceof Error ? err.message : String(err)}`);
-        return path.resolve(p);
-    }
-}
 //# sourceMappingURL=markdown-parse.js.map

package/dist/importers/markdown.js

@@ -1,12 +1,8 @@
 import * as fs from 'fs';
 import { importEntries } from './core.js';
-// ---------------------------------------------------------------------------
-// Structured markdown importer (MEMORY.md / AGENTS.md format)
-// ---------------------------------------------------------------------------
-/**
- * Slugify a heading for use as a tag.
- * "Data Pipeline & Cache" -> "data-pipeline-cache"
- */
+const SLUG_MAX_CHARS = 50;
+/** Slugify a heading for use as a tag.
+ *  "Data Pipeline & Cache" -> "data-pipeline-cache" */
 function slugify(heading) {
     return heading
         .toLowerCase()
@@ -14,13 +10,9 @@ function slugify(heading) {
         .trim()
         .replace(/\s+/g, '-')
         .replace(/-+/g, '-')
-        .slice(0, 50);
+        .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

@@ -1,26 +1,19 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import { importEntries, isJsonPlainObject } from './core.js';
-import { parseFrontmatter, collectMarkdownFiles } from './markdown-parse.js';
-import { isJsonString } from '../json.js';
+import { importEntries } from './core.js';
+import { splitMarkdownFrontmatter, collectMarkdownFiles } from './markdown-parse.js';
+import { isJsonString, isJsonObject } from '../util/json.js';
 /** Coerce one imported record (string, `{content|text: ...}` object, or
  *  anything else) into the plain-text memory chunk it represents. */
 function extractMemoryText(candidate) {
     if (isJsonString(candidate))
         return candidate;
-    if (isJsonPlainObject(candidate)) {
+    if (isJsonObject(candidate)) {
         return String(candidate['content'] ?? candidate['text'] ?? '');
     }
     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
@@ -28,7 +21,7 @@ function parseChatGPTFile(filePath) {
         try {
             const parsed = JSON.parse(raw);
             // {"memories": [...]} - ChatGPT export format
-            if (isJsonPlainObject(parsed) && Array.isArray(parsed.memories)) {
+            if (isJsonObject(parsed) && Array.isArray(parsed.memories)) {
                 return parsed.memories.map(extractMemoryText).filter(Boolean);
             }
             // Array format
@@ -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,62 +50,62 @@ 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');
     let current = '';
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Heading: start a new chunk
-        if (/^#{1,6}\s+/.test(trimmed)) {
-            if (current.trim())
-                chunks.push(current.trim());
-            current = trimmed;
-            continue;
+    for (const line of lines)
+        current = appendLine(chunks, current, line);
+    if (current.trim())
+        chunks.push(current.trim());
+    return chunks.filter(Boolean);
+}
+/** Takes one line into the chunk being built, pushing that chunk when the line ends it; returns the chunk still open. */
+function appendLine(chunks, open, line) {
+    let current = open;
+    const trimmed = line.trim();
+    // Heading: start a new chunk
+    if (/^#{1,6}\s+/.test(trimmed)) {
+        if (current.trim())
+            chunks.push(current.trim());
+        current = trimmed;
+        return current;
+    }
+    // Bullet point: each bullet is its own chunk (flush previous if not a bullet context)
+    if (/^[-*+]\s+/.test(trimmed)) {
+        if (current.trim() && !/^[-*+]\s+/.test(current.split('\n')[0])) {
+            chunks.push(current.trim());
+            current = '';
         }
-        // Bullet point: each bullet is its own chunk (flush previous if not a bullet context)
-        if (/^[-*+]\s+/.test(trimmed)) {
-            if (current.trim() && !/^[-*+]\s+/.test(current.split('\n')[0])) {
-                chunks.push(current.trim());
-                current = '';
-            }
-            if (current.trim()) {
-                chunks.push(current.trim());
-                current = '';
-            }
-            current = trimmed.replace(/^[-*+]\s+/, '').trim();
-            continue;
+        if (current.trim()) {
+            chunks.push(current.trim());
+            current = '';
         }
-        // Numbered list item
-        if (/^\d+\.\s+/.test(trimmed)) {
-            if (current.trim()) {
-                chunks.push(current.trim());
-                current = '';
-            }
-            current = trimmed.replace(/^\d+\.\s+/, '').trim();
-            continue;
+        current = trimmed.replace(/^[-*+]\s+/, '').trim();
+        return current;
+    }
+    // Numbered list item
+    if (/^\d+\.\s+/.test(trimmed)) {
+        if (current.trim()) {
+            chunks.push(current.trim());
+            current = '';
         }
-        // Empty line
-        if (!trimmed) {
-            if (current.trim()) {
-                chunks.push(current.trim());
-                current = '';
-            }
-            continue;
+        current = trimmed.replace(/^\d+\.\s+/, '').trim();
+        return current;
+    }
+    // Empty line
+    if (!trimmed) {
+        if (current.trim()) {
+            chunks.push(current.trim());
+            current = '';
         }
-        // Regular line: append to current
-        current = current ? current + ' ' + trimmed : trimmed;
+        return current;
     }
-    if (current.trim())
-        chunks.push(current.trim());
-    return chunks.filter(Boolean);
+    // 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
@@ -140,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');
@@ -198,18 +181,11 @@ export function importCursor(sourcePath, options) {
         : [sourcePath];
     const chunks = files.flatMap((file) => {
         const raw = fs.readFileSync(file, 'utf8');
-        return parseCursorFile(CURSOR_RULE_FILE.test(file) ? parseFrontmatter(raw).body : raw);
+        return parseCursorFile(CURSOR_RULE_FILE.test(file) ? splitMarkdownFrontmatter(raw).body : raw);
     });
     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