hafez 1.0.1

package/dist/sections.js

@@ -0,0 +1,297 @@
+// src/sections.ts
+// Pure string→string functions for Brief and Next Actions section manipulation.
+import { ALL_CONTRACTS, SUBTYPE_SECTIONS } from './contracts.js';
+const UNCHECKED_RE = /^- \[ \] (.+)$/gm;
+/**
+ * Known structural section headings in Hafez entities and knowledge notes.
+ * Derived from contracts.ts (defaultSections + optionalSections) plus
+ * auto-generated sections not tracked in contracts (Related, Summary).
+ * Only these are treated as section boundaries. Any other `## ` heading
+ * inside section content (e.g. in a brief or session log) is preserved as-is.
+ */
+export const STRUCTURAL_SECTIONS = new Set([
+    ...ALL_CONTRACTS.flatMap(c => [...c.defaultSections, ...c.optionalSections]),
+    ...Object.values(SUBTYPE_SECTIONS).flat(),
+    'Related', // auto-generated by syncRelatedSection
+    'Summary', // used in session files
+]);
+/**
+ * Find the next structural `## Heading` boundary after a given position.
+ * Skips `## ` headings that are not known structural sections (content headings).
+ * Returns the index of the `\n` before the `## `, or -1 if no structural heading found.
+ */
+export function findNextStructuralHeading(body, from) {
+    const re = /\n## ([^\n]+)/g;
+    re.lastIndex = from;
+    let match;
+    while ((match = re.exec(body)) !== null) {
+        const headingName = match[1].trim();
+        if (STRUCTURAL_SECTIONS.has(headingName)) {
+            return match.index;
+        }
+    }
+    return -1;
+}
+// --- Internal helpers ---
+/**
+ * Find a ## Heading section and its content.
+ * Returns { start, end, content } or null if not found.
+ * Matches heading exactly (e.g. "## Brief" won't match "## Briefing").
+ * Only treats known structural headings as section boundaries -- content
+ * inside a section may contain arbitrary `## ` headings without corruption.
+ */
+export function findSection(body, heading) {
+    const re = new RegExp(`(^|\\n)(## ${escapeRegex(heading)})(?:\\n|$)`);
+    const match = re.exec(body);
+    if (!match)
+        return null;
+    const start = match.index + match[1].length;
+    const afterHeading = start + match[2].length + 1;
+    // Find the next structural ## heading or EOF
+    const nextHeading = findNextStructuralHeading(body, afterHeading);
+    const end = nextHeading === -1 ? body.length : nextHeading;
+    const rawContent = body.slice(afterHeading, end);
+    const content = rawContent.replace(/^\n+/, '').replace(/\n+$/, '');
+    return { start, end, content };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Remove a section (heading + content) from body, cleaning up extra whitespace.
+ */
+function removeSection(body, heading) {
+    const section = findSection(body, heading);
+    if (!section)
+        return body;
+    const before = body.slice(0, section.start);
+    const after = body.slice(section.end);
+    // Clean up: avoid triple+ newlines at the splice point
+    const trimmedBefore = before.replace(/\n+$/, '');
+    const trimmedAfter = after.replace(/^\n+/, '');
+    if (!trimmedBefore)
+        return trimmedAfter;
+    if (!trimmedAfter)
+        return trimmedBefore;
+    return trimmedBefore + '\n\n' + trimmedAfter;
+}
+/**
+ * Insert a new section before a target heading, or at EOF.
+ * `before` is an array of headings to try inserting before (first found wins).
+ */
+function insertSectionBefore(body, heading, content, before) {
+    const sectionBlock = `## ${heading}\n\n${content}`;
+    for (const target of before) {
+        const targetSection = findSection(body, target);
+        if (targetSection) {
+            const insertPoint = targetSection.start;
+            const textBefore = body.slice(0, insertPoint).replace(/\n+$/, '');
+            const textAfter = body.slice(insertPoint);
+            if (!textBefore)
+                return sectionBlock + '\n\n' + textAfter;
+            return textBefore + '\n\n' + sectionBlock + '\n\n' + textAfter;
+        }
+    }
+    // No target found — append at EOF
+    const trimmed = body.replace(/\n+$/, '');
+    return trimmed + '\n\n' + sectionBlock;
+}
+/**
+ * Insert a new section after a target heading (and its content), or fall back to inserting before fallbacks.
+ */
+function insertSectionAfter(body, heading, content, after, beforeFallbacks) {
+    const afterSection = findSection(body, after);
+    if (afterSection) {
+        const insertPoint = afterSection.end;
+        const textBefore = body.slice(0, insertPoint).replace(/\n+$/, '');
+        const textAfter = body.slice(insertPoint).replace(/^\n+/, '');
+        const sectionBlock = `## ${heading}\n\n${content}`;
+        if (!textAfter)
+            return textBefore + '\n\n' + sectionBlock;
+        return textBefore + '\n\n' + sectionBlock + '\n\n' + textAfter;
+    }
+    // After-target not found — fall back to insertBefore logic
+    return insertSectionBefore(body, heading, content, beforeFallbacks);
+}
+/**
+ * Normalize text for matching: trim whitespace, replace smart quotes with
+ * straight equivalents, normalize em-dashes to regular dashes.
+ * Applied to both query and action text before comparison only — stored text is unchanged.
+ */
+function normalizeForMatch(s) {
+    return s
+        .trim()
+        .replace(/[\u2018\u2019]/g, "'")
+        .replace(/[\u201C\u201D]/g, '"')
+        .replace(/\u2014/g, '-');
+}
+/**
+ * Match an action by case-insensitive substring against unchecked items.
+ * Throws on 0 or >1 matches.
+ */
+function matchAction(body, query) {
+    const section = findSection(body, 'Next Actions');
+    if (!section)
+        throw new Error(`No matching action for "${query}"`);
+    const normalizedQuery = normalizeForMatch(query).toLowerCase();
+    const matches = [];
+    const allActions = [];
+    let m;
+    const re = new RegExp(UNCHECKED_RE.source, 'gm');
+    while ((m = re.exec(section.content)) !== null) {
+        allActions.push(m[1]);
+        if (normalizeForMatch(m[1]).toLowerCase().includes(normalizedQuery)) {
+            matches.push(m[1]);
+        }
+    }
+    if (matches.length === 0) {
+        throw new Error(`No matching action for "${query}". Actions: ${JSON.stringify(allActions)}`);
+    }
+    if (matches.length > 1)
+        throw new Error(`Ambiguous match for "${query}": ${matches.join(', ')}`);
+    return matches[0];
+}
+// --- Brief functions ---
+export function getBrief(body) {
+    const section = findSection(body, 'Brief');
+    if (!section)
+        return null;
+    return section.content || null;
+}
+export function setBrief(body, content) {
+    const existing = findSection(body, 'Brief');
+    if (existing) {
+        // Replace existing brief content
+        const updated = removeSection(body, 'Brief');
+        return setBrief(updated, content);
+    }
+    // Insert before: Next Actions > Current State > Session Log > EOF
+    return insertSectionBefore(body, 'Brief', content, ['Next Actions', 'Current State', 'Session Log']);
+}
+export function removeBrief(body) {
+    return removeSection(body, 'Brief');
+}
+// --- Next Actions functions ---
+export function getNextActions(body) {
+    const section = findSection(body, 'Next Actions');
+    if (!section)
+        return [];
+    const actions = [];
+    let m;
+    const re = new RegExp(UNCHECKED_RE.source, 'gm');
+    while ((m = re.exec(section.content)) !== null) {
+        actions.push(m[1]);
+    }
+    return actions;
+}
+export function addNextAction(body, action) {
+    const section = findSection(body, 'Next Actions');
+    if (section) {
+        // Add the new item at the end of unchecked items (before any checked items)
+        const lines = section.content.split('\n');
+        const lastUncheckedIdx = lines.reduce((last, line, i) => line.startsWith('- [ ] ') ? i : last, -1);
+        const insertIdx = lastUncheckedIdx === -1 ? 0 : lastUncheckedIdx + 1;
+        lines.splice(insertIdx, 0, `- [ ] ${action}`);
+        const newContent = lines.join('\n');
+        const before = body.slice(0, section.start).replace(/\n+$/, '');
+        const after = body.slice(section.end).replace(/^\n+/, '');
+        const sectionBlock = `## Next Actions\n\n${newContent}`;
+        const parts = [before, sectionBlock, after].filter(Boolean);
+        return parts.join('\n\n');
+    }
+    // No section — insert after Brief if present, otherwise before Session Log
+    return insertSectionAfter(body, 'Next Actions', `- [ ] ${action}`, 'Brief', ['Session Log']);
+}
+export function completeNextAction(body, query) {
+    const matched = matchAction(body, query);
+    // Replace the unchecked item with checked
+    const updatedBody = body.replace(`- [ ] ${matched}`, `- [x] ${matched}`);
+    // Check if any unchecked items remain
+    const remaining = getNextActions(updatedBody);
+    if (remaining.length === 0) {
+        return { matched, body: clearNextActions(updatedBody) };
+    }
+    return { matched, body: updatedBody };
+}
+export function removeNextAction(body, query) {
+    const matched = matchAction(body, query);
+    // Remove the line
+    const line = `- [ ] ${matched}`;
+    const updatedBody = body.split('\n').filter(l => l !== line).join('\n');
+    // Check if any unchecked items remain
+    const remaining = getNextActions(updatedBody);
+    if (remaining.length === 0) {
+        return { matched, body: clearNextActions(updatedBody) };
+    }
+    return { matched, body: updatedBody };
+}
+export function clearNextActions(body) {
+    return removeSection(body, 'Next Actions');
+}
+// --- Summary derivation ---
+export function firstNonEmptyLine(s) {
+    return s?.split('\n').find(l => l.trim())?.trim() ?? '';
+}
+/**
+ * One-line summary for a doc: frontmatter description first, then the first
+ * non-empty line of the kind's primary section (entity: Brief; knowledge:
+ * Synthesis, falling back to Goal for plans; session: Summary).
+ * Shared by the vault index and the OKF export so the two surfaces agree.
+ */
+export function deriveSummary(kind, fm, body) {
+    if (fm.description)
+        return fm.description;
+    if (kind === 'entity')
+        return firstNonEmptyLine(getBrief(body));
+    if (kind === 'knowledge') {
+        const synthesis = findSection(body, 'Synthesis');
+        if (synthesis?.content)
+            return firstNonEmptyLine(synthesis.content);
+        return firstNonEmptyLine(findSection(body, 'Goal')?.content);
+    }
+    return firstNonEmptyLine(findSection(body, 'Summary')?.content);
+}
+// --- Related section functions ---
+/** Matches [[slug]] or [[slug|display text]], capturing slug in group 1. Non-global — wrap with `new RegExp(WIKI_LINK_RE.source, 'g')` for iteration. */
+export const WIKI_LINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/;
+export function syncRelatedSection(body, frontmatter) {
+    const targets = [];
+    if (frontmatter.parent)
+        targets.push({ slug: frontmatter.parent, label: 'parent' });
+    for (const slug of frontmatter.related ?? [])
+        targets.push({ slug });
+    if (targets.length === 0) {
+        // No frontmatter links — remove Related section if present
+        const existing = findSection(body, 'Related');
+        if (!existing)
+            return body;
+        const before = body.slice(0, existing.start).replace(/\n+$/, '');
+        const after = body.slice(existing.end).replace(/^\n+/, '');
+        return [before, after].filter(Boolean).join('\n\n');
+    }
+    // Strip existing Related section before checking coverage
+    let authoredBody = body;
+    const existingRelated = findSection(body, 'Related');
+    if (existingRelated) {
+        const before = body.slice(0, existingRelated.start);
+        const after = body.slice(existingRelated.end);
+        authoredBody = (before + after).replace(/\n{3,}/g, '\n\n');
+    }
+    // Find which targets are NOT mentioned in authored body
+    const mentionedSlugs = new Set();
+    let match;
+    const re = new RegExp(WIKI_LINK_RE.source, 'g');
+    while ((match = re.exec(authoredBody)) !== null) {
+        mentionedSlugs.add(match[1]);
+    }
+    const uncovered = targets.filter(t => !mentionedSlugs.has(t.slug));
+    if (uncovered.length === 0) {
+        // All covered inline — return body without Related section
+        return authoredBody.replace(/\n+$/, '');
+    }
+    // Build Related section
+    const lines = uncovered.map(t => t.label ? `- [[${t.slug}]] (${t.label})` : `- [[${t.slug}]]`);
+    const section = `## Related\n\n${lines.join('\n')}`;
+    // Append at end
+    return authoredBody.replace(/\n+$/, '') + '\n\n' + section;
+}

package/dist/templates.d.ts

@@ -0,0 +1,8 @@
+import type { EntityType, KnowledgeSubtype } from './types.js';
+export declare function bodyTemplate(type: EntityType, fields?: {
+    purpose?: string;
+    notes?: string;
+}): string;
+export declare function knowledgeBodyTemplate(subtype?: KnowledgeSubtype, fields?: {
+    synthesis?: string;
+}): string;

package/dist/templates.js

@@ -0,0 +1,39 @@
+import { SUBTYPE_SECTIONS } from './contracts.js';
+const ITEM_TEMPLATES = {
+    capture: ['## Notes'],
+    entity: ['## Context', '## Session Log'],
+    project: ['## Purpose', '## Goals', '## Session Log'],
+};
+export function bodyTemplate(type, fields) {
+    const sections = ITEM_TEMPLATES[type];
+    if (!sections)
+        throw new Error(`Unknown item type: ${type}`);
+    const lines = [];
+    for (const section of sections) {
+        lines.push(section);
+        if (section === '## Purpose' && fields?.purpose) {
+            lines.push('', fields.purpose);
+        }
+        if (section === '## Notes' && fields?.notes) {
+            lines.push('', fields.notes);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+export function knowledgeBodyTemplate(subtype, fields) {
+    if (subtype === 'session') {
+        throw new Error("subtype 'session' is no longer supported for knowledge notes. " +
+            "Use batch kind: 'session' instead. See knowledge-v2 migration.");
+    }
+    const sections = SUBTYPE_SECTIONS[subtype ?? 'insight'];
+    const lines = [];
+    for (const section of sections) {
+        lines.push(`## ${section}`);
+        if ((section === 'Synthesis' || section === 'Summary') && fields?.synthesis) {
+            lines.push('', fields.synthesis);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}

package/dist/types.d.ts

@@ -0,0 +1,321 @@
+export type EntityType = 'capture' | 'entity' | 'project';
+export type EntityStatus = 'active' | 'paused' | 'done';
+export type ConfidenceLevel = 'observation' | 'pattern' | 'principle';
+export type SessionLogType = 'progress' | 'decision' | 'blocker' | 'research';
+export type ReadDepth = 'frontmatter' | 'summary' | 'full';
+export type QueryFilter = 'active' | 'paused' | 'done' | 'all' | 'stale' | 'capture';
+export type LinkRelation = 'parent' | 'related';
+export type KnowledgeSubtype = 'insight' | 'plan';
+export interface EntityQueryOpts {
+    filter?: QueryFilter;
+    type?: EntityType;
+    parent?: string;
+    domain?: string;
+    confidence?: ConfidenceLevel;
+    since?: string;
+    before?: string;
+    createdSince?: string;
+    createdBefore?: string;
+    tags?: string[];
+    sort_by?: 'last_touched' | 'created' | 'name' | 'staleness' | 'last_reinforced' | 'reinforcement_count';
+    sort_order?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+export interface KnowledgeQueryOpts {
+    domain?: string;
+    confidence?: ConfidenceLevel;
+    subtype?: KnowledgeSubtype;
+    tags?: string[];
+    sort_by?: 'last_touched' | 'created' | 'name' | 'staleness' | 'last_reinforced' | 'reinforcement_count';
+    sort_order?: 'asc' | 'desc';
+    limit?: number;
+    offset?: number;
+}
+export interface EntityFrontmatter {
+    name: string;
+    type: EntityType;
+    status: EntityStatus;
+    description?: string;
+    resource?: string;
+    domain?: string[];
+    parent?: string;
+    related?: string[];
+    created: string;
+    'last-touched': string;
+    'staleness-days'?: number;
+    tags?: string[];
+}
+export interface KnowledgeFrontmatter {
+    name: string;
+    subtype?: KnowledgeSubtype;
+    description?: string;
+    domain?: string[];
+    confidence?: ConfidenceLevel;
+    related?: string[];
+    created: string;
+    'last-reinforced'?: string;
+    'reinforcement-count'?: number;
+    tags?: string[];
+    'session-date'?: string;
+    status?: 'active' | 'done';
+    'last-touched'?: string;
+}
+export interface ParsedFile<T = EntityFrontmatter | KnowledgeFrontmatter> {
+    frontmatter: T;
+    body: string;
+}
+export interface SessionLogEntry {
+    type: SessionLogType;
+    summary: string;
+    body?: string;
+    agent: string;
+}
+export interface ParsedSessionLogEntry {
+    date: string;
+    agent: string;
+    type: SessionLogType;
+    summary: string;
+    body: string;
+}
+export interface UpdateFields {
+    status?: EntityStatus;
+    next_action?: string | null;
+    current_state?: string;
+    session_log?: SessionLogEntry;
+    brief?: string | null;
+    add_action?: string;
+    add_actions?: string[];
+    complete_action?: string;
+    remove_action?: string;
+    clear_actions?: boolean;
+    description?: string | null;
+    resource?: string | null;
+    domain?: string[];
+    confidence?: ConfidenceLevel;
+    tags?: string[];
+    related?: string[];
+    synthesis?: string;
+    add_evidence?: string;
+    add_source?: string;
+}
+export interface UpdateResult {
+    previous_next_action?: string | null;
+    matched_action?: string;
+}
+export interface CreateEntityFields {
+    type: EntityType;
+    purpose?: string;
+    description?: string;
+    resource?: string;
+    domain?: string[];
+    parent?: string;
+    related?: string[];
+    tags?: string[];
+    brief?: string;
+    add_action?: string;
+}
+export interface CreateKnowledgeFields {
+    subtype?: KnowledgeSubtype;
+    synthesis?: string;
+    description?: string;
+    domain?: string[];
+    related?: string[];
+    tags?: string[];
+    'session-date'?: string;
+}
+export interface QueryResult {
+    slug: string;
+    name: string;
+    type: EntityType;
+    status: EntityStatus;
+    description: string | null;
+    resource: string | null;
+    domain: string[];
+    last_touched: string;
+    next_action: string | null;
+    next_action_count: number;
+    parent: string | null;
+    related: string[];
+    staleness_days: number | null;
+    tags: string[];
+    brief: string | null;
+    session_log_count: number;
+    last_session_date: string | null;
+    last_session_type: string | null;
+    last_session_summary: string | null;
+}
+export interface KnowledgeQueryResult {
+    slug: string;
+    name: string;
+    description: string | null;
+    domain: string[];
+    confidence: ConfidenceLevel;
+    related: string[];
+    reinforcement_count: number;
+    last_reinforced: string | null;
+    last_touched: string | null;
+}
+export type UnifiedResult = (QueryResult & {
+    kind: 'entity';
+}) | (KnowledgeQueryResult & {
+    kind: 'knowledge';
+});
+export interface ValidationIssue {
+    slug: string;
+    field: string;
+    issue: string;
+}
+export interface ValidationReport {
+    broken_slugs: ValidationIssue[];
+    orphaned_knowledge: string[];
+    oversized_related: ValidationIssue[];
+    missing_fields: ValidationIssue[];
+    total_entities: number;
+    total_knowledge: number;
+}
+export interface SearchResult {
+    slug: string;
+    kind: 'entity' | 'knowledge';
+    name: string;
+    snippet: string;
+    type?: EntityType;
+    status?: EntityStatus;
+    confidence?: ConfidenceLevel;
+}
+export interface VaultStats {
+    counts: Record<EntityStatus, number>;
+    by_type: Record<EntityType, number>;
+    knowledge_count: number;
+    stale: Array<{
+        slug: string;
+        name: string;
+        type: EntityType;
+        days_since_touched: number;
+    }>;
+    no_next_action: Array<{
+        slug: string;
+        name: string;
+        type: EntityType;
+    }>;
+    recently_touched: Array<{
+        slug: string;
+        name: string;
+        last_touched: string;
+    }>;
+    recently_created: Array<{
+        slug: string;
+        name: string;
+        created: string;
+    }>;
+}
+export interface ChangelogEntry {
+    slug: string;
+    kind: 'entity' | 'knowledge';
+    operation: 'created' | 'updated' | 'deleted';
+    timestamp: string;
+    commit_message: string;
+}
+export interface BatchResult {
+    op: string;
+    slug: string;
+    status: 'ok' | 'error';
+    error?: string;
+    created?: boolean;
+}
+export type BatchOperation = {
+    op: 'update';
+    slug: string;
+    fields: UpdateFields;
+} | {
+    op: 'create';
+    kind: 'entity';
+    name: string;
+    fields: CreateEntityFields;
+} | {
+    op: 'create';
+    kind: 'knowledge';
+    name: string;
+    fields?: CreateKnowledgeFields;
+} | {
+    op: 'create';
+    kind: 'session';
+    name: string;
+    fields?: CreateKnowledgeFields;
+} | {
+    op: 'capture';
+    name: string;
+    notes?: string;
+} | {
+    op: 'link';
+    slug: string;
+    target: string;
+    relation: LinkRelation;
+} | {
+    op: 'unlink';
+    slug: string;
+    target: string;
+    relation: LinkRelation;
+} | {
+    op: 'promote';
+    slug: string;
+    target: 'entity' | 'project' | 'knowledge';
+};
+export type HafezErrorCode = 'NOT_FOUND' | 'SLUG_EXISTS' | 'VALIDATION_FAILED' | 'GIT_PUSH_FAILED';
+export declare class HafezError extends Error {
+    code: HafezErrorCode;
+    details?: string[] | undefined;
+    constructor(code: HafezErrorCode, message: string, details?: string[] | undefined);
+}
+export interface GitConfig {
+    push?: boolean;
+}
+export interface HafezConfig {
+    vaultPath: string;
+    readOnly?: boolean;
+    git?: GitConfig;
+    onWrite?: (slug: string, operation: string) => void;
+}
+export interface Hafez {
+    read(slug: string, depth?: ReadDepth): Promise<ParsedFile>;
+    update(slug: string, fields: UpdateFields): Promise<UpdateResult>;
+    query(opts?: EntityQueryOpts): Promise<{
+        items: QueryResult[];
+        total: number;
+    }>;
+    queryUnified(opts?: EntityQueryOpts & {
+        kind?: 'entity' | 'knowledge' | 'all';
+    }): Promise<{
+        items: UnifiedResult[];
+        total: number;
+    }>;
+    create(kind: 'entity', name: string, fields: CreateEntityFields): Promise<string>;
+    create(kind: 'knowledge', name: string, fields?: CreateKnowledgeFields): Promise<string>;
+    capture(name: string, notes?: string): Promise<string>;
+    link(slug: string, target: string, relation: LinkRelation): Promise<void>;
+    unlink(slug: string, target: string, relation: LinkRelation): Promise<void>;
+    promote(slug: string, target: 'entity' | 'project' | 'knowledge'): Promise<string>;
+    batch(operations: BatchOperation[]): Promise<BatchResult[]>;
+    sync(): Promise<{
+        pulled: boolean;
+        pushed: boolean;
+        remote: boolean;
+    }>;
+    children(slug: string): Promise<{
+        items: QueryResult[];
+        total: number;
+    }>;
+    related_to(slug: string, relation?: string): Promise<{
+        items: (QueryResult | KnowledgeQueryResult)[];
+        total: number;
+    }>;
+    query_knowledge(opts?: KnowledgeQueryOpts): Promise<{
+        items: KnowledgeQueryResult[];
+        total: number;
+    }>;
+    validate(): Promise<ValidationReport>;
+    search(query: string, kind?: 'entity' | 'knowledge' | 'all'): Promise<SearchResult[]>;
+    rebuildIndex(): Promise<void>;
+    stats(): Promise<VaultStats>;
+    changelog(since: string): Promise<ChangelogEntry[]>;
+}

package/dist/types.js

@@ -0,0 +1,11 @@
+// src/types.ts
+export class HafezError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'HafezError';
+    }
+}

package/dist/vault.d.ts

@@ -0,0 +1,12 @@
+export declare function slugify(name: string): string;
+export declare function resolveFilePath(vaultPath: string, slug: string, kind: 'entity' | 'knowledge'): string;
+export declare function slugExists(vaultPath: string, slug: string): boolean;
+export declare function parseFilePath(path: string): {
+    frontmatter: Record<string, any>;
+    body: string;
+};
+export declare function parseContent(content: string): {
+    frontmatter: Record<string, any>;
+    body: string;
+};
+export declare function serializeFile(frontmatter: Record<string, any>, body: string): string;