Skip to content

Local-first 🧠 memory for Hermes Agent that lives in your Obsidian vault and remembers project context. Nightly 😴 dream passes turn repeat corrections into confirmed preferences with measurable confidence. Adapters ship for Claude Code, Codex, and OpenClaw, with an MCP server for anything else.

TypeScript
4.2 KB
Raw Blame
/**
 * Link-type endpoint constraints (write-time-integrity-governance).
 *
 * The schema pack's `link_constraints` field declares, per link type,
 * which `source_type->target_type` page-type pairs may carry that
 * typed relation. Enforcement happens at materialization: the
 * indexer's post-pass marks violating edges blocked so they fall back
 * to plain untyped links instead of participating in typed-relation
 * recall (polarity, traversal). Constraints constrain materialization,
 * not authoring - the frontmatter stays untouched, the flags are
 * recomputed from the current pack on every index run, and a relation
 * with no declared constraints (or an endpoint whose page type is
 * unknown) is always allowed, so an unconfigured vault is unaffected.
 */

import { Database } from "bun:sqlite";
import { existsSync } from "node:fs";
import { closeDatabase } from "../sqlite-close.ts";

export type LinkConstraintMap = Readonly<Record<string, ReadonlyArray<string>>>;

/** One typed edge whose endpoints violate the declared constraints. */
export interface LinkConstraintViolation {
  readonly relation: string;
  readonly sourcePath: string;
  readonly targetPath: string;
  readonly sourceType: string;
  readonly targetType: string;
  /** The pairs the schema pack declares for this relation. */
  readonly declared: ReadonlyArray<string>;
}

/**
 * Decide whether one typed edge may materialize. Fail-open on missing
 * information: a relation without declared constraints, or an endpoint
 * whose page type is unknown (no `type:` frontmatter, or the document
 * predates the `page_type` column), cannot be evaluated and passes.
 */
export function linkConstraintAllows(
  constraints: LinkConstraintMap,
  relation: string,
  sourceType: string | null,
  targetType: string | null,
): boolean {
  const declared = constraints[relation];
  if (declared === undefined || declared.length === 0) return true;
  if (sourceType === null || targetType === null) return true;
  return declared.includes(`${sourceType}->${targetType}`);
}

/** One blocked edge as the lint surface reads it back from the index. */
export interface BlockedRelationRow {
  readonly relation: string;
  readonly sourcePath: string;
  readonly targetPath: string;
  readonly sourceType: string | null;
  readonly targetType: string | null;
}

/**
 * Read the edges the last index pass blocked, straight from the index
 * database. Lint-surface companion to the indexer post-pass: read-only,
 * fail-soft - a missing index file, a pre-v6 schema, or any read error
 * yields an empty list rather than failing the lint.
 */
export function readBlockedRelationRows(dbPath: string): ReadonlyArray<BlockedRelationRow> {
  if (!existsSync(dbPath)) return [];
  let db: Database | null = null;
  try {
    db = new Database(dbPath, { readonly: true });
    return db
      .query<
        {
          relation: string;
          source_path: string;
          target_path: string | null;
          source_type: string | null;
          target_type: string | null;
        },
        []
      >(
        "SELECT l.relation, sd.path AS source_path, l.target_path, " +
          "  sd.page_type AS source_type, td.page_type AS target_type " +
          "FROM links l " +
          "JOIN documents sd ON sd.id = l.source_document_id " +
          "LEFT JOIN documents td ON td.id = COALESCE(" +
          "    l.target_document_id, " +
          "    (SELECT d.id FROM documents d WHERE d.path = l.target_path || '.md'), " +
          "    (SELECT d.id FROM documents d " +
          "       WHERE SUBSTR(d.path, -(LENGTH(l.target_path) + 4)) = '/' || l.target_path || '.md' " +
          "       AND 1 = (SELECT COUNT(*) FROM documents d2 " +
          "                WHERE SUBSTR(d2.path, -(LENGTH(l.target_path) + 4)) = '/' || l.target_path || '.md'))" +
          "  ) " +
          "WHERE l.relation IS NOT NULL AND l.relation_blocked = 1 " +
          "ORDER BY sd.path, l.id",
      )
      .all()
      .map((r) => ({
        relation: r.relation,
        sourcePath: r.source_path,
        targetPath: r.target_path ?? "",
        sourceType: r.source_type,
        targetType: r.target_type,
      }));
  } catch {
    return [];
  } finally {
    closeDatabase(db);
  }
}