@gmickel/gno 1.9.0 → 1.10.0

package/src/core/graph-resolver.ts

@@ -0,0 +1,117 @@
+/**
+ * Shared SQL expressions for graph link target resolution.
+ *
+ * These helpers preserve getGraph's existing wiki matching order so future
+ * typed-edge projection/backfill can reuse the exact resolver.
+ *
+ * @module src/core/graph-resolver
+ */
+
+const suffixMatch = (targetExpr: string, valueExpr: string): string =>
+  `(substr(${targetExpr}, -length(${valueExpr})) = ${valueExpr}
+    AND (length(${targetExpr}) = length(${valueExpr})
+      OR substr(${targetExpr}, -length(${valueExpr}) - 1, 1) = '/'))`;
+
+const wikiTitleExpr = (alias: string): string => `lower(trim(${alias}.title))`;
+const wikiRelPathExpr = (alias: string): string => `lower(${alias}.rel_path)`;
+
+function wikiTargetExpressions(targetRefExpr: string): {
+  targetBaseExpr: string;
+  targetMdExpr: string;
+} {
+  const targetBaseExpr = `CASE
+    WHEN ${targetRefExpr} LIKE '%.md' THEN substr(${targetRefExpr}, 1, length(${targetRefExpr}) - 3)
+    ELSE ${targetRefExpr}
+  END`;
+  return { targetBaseExpr, targetMdExpr: `${targetBaseExpr} || '.md'` };
+}
+
+export function buildWikiMatchExpression(
+  alias: string,
+  targetRefExpr: string
+): string {
+  const titleExpr = wikiTitleExpr(alias);
+  const relExpr = wikiRelPathExpr(alias);
+  const { targetBaseExpr, targetMdExpr } = wikiTargetExpressions(targetRefExpr);
+  return `(
+    ${titleExpr} = ${targetBaseExpr}
+    OR ${titleExpr} = ${targetMdExpr}
+    OR ${suffixMatch(targetBaseExpr, titleExpr)}
+    OR ${suffixMatch(targetMdExpr, `${titleExpr} || '.md'`)}
+    OR ${relExpr} = ${targetBaseExpr}
+    OR ${relExpr} = ${targetMdExpr}
+    OR ${suffixMatch(relExpr, targetMdExpr)}
+    OR ${suffixMatch(relExpr, targetBaseExpr)}
+    OR ${suffixMatch(targetMdExpr, relExpr)}
+    OR ${suffixMatch(targetBaseExpr, relExpr)}
+  )`;
+}
+
+export function buildWikiOrderExpression(
+  alias: string,
+  targetRefExpr: string
+): string {
+  const titleExpr = wikiTitleExpr(alias);
+  const relExpr = wikiRelPathExpr(alias);
+  const { targetBaseExpr, targetMdExpr } = wikiTargetExpressions(targetRefExpr);
+  return `CASE
+    WHEN ${titleExpr} = ${targetBaseExpr} THEN 1
+    WHEN ${titleExpr} = ${targetMdExpr} THEN 2
+    WHEN ${suffixMatch(targetBaseExpr, titleExpr)} THEN 3
+    WHEN ${suffixMatch(targetMdExpr, `${titleExpr} || '.md'`)} THEN 4
+    WHEN ${relExpr} = ${targetBaseExpr} THEN 5
+    WHEN ${relExpr} = ${targetMdExpr} THEN 6
+    WHEN ${suffixMatch(relExpr, targetMdExpr)} THEN 7
+    WHEN ${suffixMatch(relExpr, targetBaseExpr)} THEN 8
+    WHEN ${suffixMatch(targetMdExpr, relExpr)} THEN 9
+    WHEN ${suffixMatch(targetBaseExpr, relExpr)} THEN 10
+    ELSE 11
+  END`;
+}
+
+export function buildWikiBestMatchSubquery(
+  collectionExpr: string,
+  targetRefExpr: string
+): string {
+  return `
+    SELECT t.id FROM documents t
+    WHERE t.active = 1
+      AND t.collection = ${collectionExpr}
+      AND ${buildWikiMatchExpression("t", targetRefExpr)}
+      AND ${buildWikiOrderExpression("t", targetRefExpr)} = (
+        SELECT MIN(${buildWikiOrderExpression("t2", targetRefExpr)}) FROM documents t2
+        WHERE t2.active = 1
+          AND t2.collection = ${collectionExpr}
+          AND ${buildWikiMatchExpression("t2", targetRefExpr)}
+      )
+    ORDER BY t.id LIMIT 1
+  `;
+}
+
+export function buildWikiBestRankSubquery(
+  collectionExpr: string,
+  targetRefExpr: string
+): string {
+  return `
+    SELECT MIN(${buildWikiOrderExpression("t", targetRefExpr)}) FROM documents t
+    WHERE t.active = 1
+      AND t.collection = ${collectionExpr}
+      AND ${buildWikiMatchExpression("t", targetRefExpr)}
+  `;
+}
+
+export function buildWikiBestRankMatchCountSubquery(
+  collectionExpr: string,
+  targetRefExpr: string
+): string {
+  return `
+    SELECT COUNT(*) FROM documents t
+    WHERE t.active = 1
+      AND t.collection = ${collectionExpr}
+      AND ${buildWikiMatchExpression("t", targetRefExpr)}
+      AND ${buildWikiOrderExpression("t", targetRefExpr)} = (${buildWikiBestRankSubquery(
+        collectionExpr,
+        targetRefExpr
+      )})
+  `;
+}

package/src/core/ref-parser.ts

@@ -0,0 +1,145 @@
+/**
+ * Reference parser and resolver for document refs.
+ * Pure parsing helpers stay store-free; resolution depends only on StorePort.
+ *
+ * @module src/core/ref-parser
+ */
+
+import type { DocumentRow, StorePort } from "../store/types";
+
+export type RefType = "docid" | "uri" | "collPath";
+
+export interface ParsedRef {
+  type: RefType;
+  /** Normalized ref (without :line suffix) */
+  value: string;
+  /** For collPath type */
+  collection?: string;
+  /** For collPath type */
+  relPath?: string;
+  /** Parsed :line suffix (1-indexed) */
+  line?: number;
+}
+
+export type ParseRefResult = ParsedRef | { error: string };
+
+export type ResolvedDocRef =
+  | { doc: DocumentRow }
+  | { error: string; isValidation: boolean };
+
+const DOCID_PATTERN = /^#[a-f0-9]{6,}$/;
+const LINE_SUFFIX_PATTERN = /:(\d+)$/;
+const GLOB_PATTERN = /[*?[\]]/;
+
+/**
+ * Parse a single ref string.
+ * - Docid: starts with # (no :line suffix allowed)
+ * - URI: starts with gno:// (optional :N suffix)
+ * - Else: collection/path (optional :N suffix)
+ */
+export function parseRef(ref: string): ParseRefResult {
+  if (ref.startsWith("#")) {
+    if (ref.includes(":")) {
+      return { error: "Docid refs cannot have :line suffix" };
+    }
+    if (!DOCID_PATTERN.test(ref)) {
+      return { error: `Invalid docid format: ${ref}` };
+    }
+    return { type: "docid", value: ref };
+  }
+
+  let line: number | undefined;
+  let baseRef = ref;
+  const lineMatch = ref.match(LINE_SUFFIX_PATTERN);
+  if (lineMatch?.[1]) {
+    const parsed = Number.parseInt(lineMatch[1], 10);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+      return { error: `Invalid line suffix (must be >= 1): ${ref}` };
+    }
+    line = parsed;
+    baseRef = ref.slice(0, -lineMatch[0].length);
+  }
+
+  if (baseRef.startsWith("gno://")) {
+    return { type: "uri", value: baseRef, line };
+  }
+
+  const slashIdx = baseRef.indexOf("/");
+  if (slashIdx === -1) {
+    return { error: `Invalid ref format (missing /): ${ref}` };
+  }
+  const collection = baseRef.slice(0, slashIdx);
+  const relPath = baseRef.slice(slashIdx + 1);
+
+  return { type: "collPath", value: baseRef, collection, relPath, line };
+}
+
+/**
+ * Resolve a document reference against the store.
+ */
+export async function resolveDocRef(
+  store: StorePort,
+  docRef: string
+): Promise<ResolvedDocRef> {
+  const parsed = parseRef(docRef);
+
+  if ("error" in parsed) {
+    return { error: parsed.error, isValidation: true };
+  }
+
+  let doc: DocumentRow | null = null;
+
+  switch (parsed.type) {
+    case "docid": {
+      const result = await store.getDocumentByDocid(parsed.value);
+      if (result.ok && result.value) {
+        doc = result.value;
+      }
+      break;
+    }
+    case "uri": {
+      const result = await store.getDocumentByUri(parsed.value);
+      if (result.ok && result.value) {
+        doc = result.value;
+      }
+      break;
+    }
+    case "collPath": {
+      const uri = `gno://${parsed.collection}/${parsed.relPath}`;
+      const result = await store.getDocumentByUri(uri);
+      if (result.ok && result.value) {
+        doc = result.value;
+      }
+      break;
+    }
+  }
+
+  if (!doc) {
+    return { error: `Document not found: ${docRef}`, isValidation: true };
+  }
+
+  return { doc };
+}
+
+/**
+ * Split comma-separated refs. Does NOT expand globs.
+ */
+export function splitRefs(refs: string[]): string[] {
+  const result: string[] = [];
+  for (const r of refs) {
+    for (const part of r.split(",")) {
+      const trimmed = part.trim();
+      if (trimmed) {
+        result.push(trimmed);
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Check if a ref contains glob characters.
+ */
+export function isGlobPattern(ref: string): boolean {
+  return GLOB_PATTERN.test(ref);
+}

package/src/ingestion/frontmatter.ts

@@ -170,11 +170,95 @@ function parseBlockArrayValue(lines: string[], startIdx: number): string[] {
   return items;
 }
 
+function countIndent(line: string): number {
+  let indent = 0;
+  for (const char of line) {
+    if (char === " ") {
+      indent += 1;
+    } else if (char === "\t") {
+      indent += 2;
+    } else {
+      break;
+    }
+  }
+  return indent;
+}
+
+function parseNestedMapValue(
+  lines: string[],
+  startIdx: number
+): Record<string, string[]> {
+  const result: Record<string, string[]> = {};
+
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined) break;
+    if (line.trim().length === 0) continue;
+    if (!line.startsWith(" ") && !line.startsWith("\t")) {
+      break;
+    }
+
+    const keyIndent = countIndent(line);
+    const trimmed = line.trim();
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx <= 0) {
+      continue;
+    }
+
+    const key = trimmed.slice(0, colonIdx).trim();
+    const rawValue = trimmed.slice(colonIdx + 1).trim();
+    const values: string[] = [];
+
+    const inlineArray = parseInlineArrayValue(rawValue);
+    if (inlineArray) {
+      values.push(...inlineArray);
+    } else if (rawValue.length > 0) {
+      values.push(unquoteScalar(rawValue));
+    } else {
+      for (let j = i + 1; j < lines.length; j++) {
+        const childLine = lines[j];
+        if (childLine === undefined) break;
+        if (childLine.trim().length === 0) continue;
+        const childIndent = countIndent(childLine);
+        if (childIndent <= keyIndent) {
+          break;
+        }
+        const itemMatch = YAML_ARRAY_ITEM_REGEX.exec(childLine);
+        if (itemMatch?.[1]) {
+          const item = unquoteScalar(itemMatch[1]);
+          if (item.length > 0) {
+            values.push(item);
+          }
+        }
+      }
+    }
+
+    if (key.length > 0 && values.length > 0) {
+      result[key] = values;
+    }
+  }
+
+  return result;
+}
+
+function startsNestedMap(lines: string[], startIdx: number): boolean {
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined) break;
+    if (line.trim().length === 0) continue;
+    if (!line.startsWith(" ") && !line.startsWith("\t")) {
+      return false;
+    }
+    return line.trim().indexOf(":") > 0;
+  }
+  return false;
+}
+
 function parseMetadataValue(
   value: string,
   lines: string[],
   startIdx: number
-): string | string[] | undefined {
+): string | string[] | Record<string, string[]> | undefined {
   const trimmed = value.trim();
   const inlineArray = parseInlineArrayValue(trimmed);
   if (inlineArray) {
@@ -182,8 +266,14 @@ function parseMetadataValue(
   }
 
   if (trimmed.length === 0) {
+    if (startsNestedMap(lines, startIdx)) {
+      const nestedMap = parseNestedMapValue(lines, startIdx);
+      return Object.keys(nestedMap).length > 0 ? nestedMap : undefined;
+    }
     const blockArray = parseBlockArrayValue(lines, startIdx);
-    return blockArray.length > 0 ? blockArray : undefined;
+    if (blockArray.length > 0) {
+      return blockArray;
+    }
   }
 
   return unquoteScalar(trimmed);
@@ -222,6 +312,9 @@ export function parseFrontmatter(source: string): FrontmatterResult {
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
       if (line === undefined) continue;
+      if (line.startsWith(" ") || line.startsWith("\t")) {
+        continue;
+      }
 
       // Logseq format: tags:: value
       const logseqMatch = LOGSEQ_TAGS_REGEX.exec(line);

package/src/ingestion/sync.ts

@@ -14,6 +14,7 @@ import type { NormalizedContentTypeRule } from "../config";
 import type { Collection } from "../config/types";
 import type {
   ChunkInput,
+  DocEdgeInput,
   DocLinkInput,
   DocumentRow,
   IngestErrorInput,
@@ -43,6 +44,7 @@ import {
   normalizeMarkdownPath,
   normalizeWikiName,
   parseLinks,
+  parseTargetParts,
 } from "../core/links";
 import { normalizeTag, validateTag } from "../core/tags";
 import { defaultChunker } from "./chunker";
@@ -70,8 +72,130 @@ const MAX_CONCURRENCY = 16;
  * Increment when ingestion adds new derived data (tags, metadata, etc.)
  * Documents with ingestVersion < INGEST_VERSION will be re-processed.
  */
-export const INGEST_VERSION = 5;
+export const INGEST_VERSION = 6;
 const EMPTY_CONTENT_TYPE_RULES_FINGERPRINT = fingerprintContentTypeRules([]);
+const RELATION_EDGE_TYPE_PATTERN = /^[a-z][a-z0-9_]*$/;
+
+type RelationMap = Record<string, string[]>;
+
+function isRelationMap(value: unknown): value is RelationMap {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+
+  return Object.values(value).every(
+    (targets) =>
+      Array.isArray(targets) &&
+      targets.every((target) => typeof target === "string")
+  );
+}
+
+function normalizeRelationTarget(raw: string): string {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[[") && trimmed.endsWith("]]")) {
+    return trimmed.slice(2, -2).split("|")[0]?.trim() ?? "";
+  }
+  return trimmed;
+}
+
+function normalizeRelationEdgeType(raw: string): string {
+  return raw
+    .trim()
+    .toLowerCase()
+    .replace(/[-\s]+/g, "_");
+}
+
+function findDocByWikiRef(
+  docs: DocumentRow[],
+  targetRef: string,
+  collection?: string
+): DocumentRow | undefined {
+  const normalized = normalizeWikiName(targetRef);
+  const candidates = collection
+    ? docs.filter((doc) => doc.collection === collection)
+    : docs;
+
+  return candidates.find((doc) => {
+    const title = doc.title ?? doc.relPath.split("/").pop() ?? doc.relPath;
+    const relStem = doc.relPath.replace(/\.[^/.]+$/, "");
+    return (
+      normalizeWikiName(title) === normalized ||
+      normalizeWikiName(doc.relPath) === normalized ||
+      normalizeWikiName(relStem) === normalized
+    );
+  });
+}
+
+function resolveRelationTarget(
+  docs: DocumentRow[],
+  sourceDoc: DocumentRow,
+  rawTarget: string
+): DocumentRow | undefined {
+  const target = normalizeRelationTarget(rawTarget);
+  if (!target) {
+    return undefined;
+  }
+
+  if (target.startsWith("#")) {
+    return docs.find((doc) => doc.docid === target);
+  }
+
+  if (target.startsWith("gno://")) {
+    return docs.find((doc) => doc.uri === target);
+  }
+
+  const parts = parseTargetParts(target);
+  const targetCollection = parts.collection;
+  const targetRef = parts.ref;
+  if (!targetRef) {
+    return undefined;
+  }
+
+  if (targetCollection) {
+    const exact = docs.find(
+      (doc) => doc.collection === targetCollection && doc.relPath === targetRef
+    );
+    return exact ?? findDocByWikiRef(docs, targetRef, targetCollection);
+  }
+
+  const sameCollectionPath = normalizeMarkdownPath(
+    targetRef,
+    sourceDoc.relPath
+  );
+  if (sameCollectionPath) {
+    const exact = docs.find(
+      (doc) =>
+        doc.collection === sourceDoc.collection &&
+        doc.relPath === sameCollectionPath
+    );
+    if (exact) {
+      return exact;
+    }
+  }
+
+  const explicitCollPath = docs.find(
+    (doc) => `${doc.collection}/${doc.relPath}` === targetRef
+  );
+  if (explicitCollPath) {
+    return explicitCollPath;
+  }
+
+  return (
+    findDocByWikiRef(docs, targetRef, sourceDoc.collection) ??
+    findDocByWikiRef(docs, targetRef)
+  );
+}
+
+function getPrimaryGraphHint(
+  contentType: string | null | undefined,
+  rules: NormalizedContentTypeRule[]
+): string | undefined {
+  if (!contentType) {
+    return undefined;
+  }
+  const rule = rules.find((candidate) => candidate.id === contentType);
+  return rule?.graphHints?.[0];
+}
 
 /**
  * Decide whether to process a file or skip it.
@@ -658,6 +782,7 @@ export class SyncService {
         converterVersion: artifact.meta.converterVersion,
         languageHint: artifact.languageHint ?? collection.languageHint,
         contentType: extractedMetadata.contentType,
+        contentTypeSource: extractedMetadata.contentTypeSource,
         categories: extractedMetadata.categories,
         author: extractedMetadata.author,
         frontmatterDate: extractedMetadata.frontmatterDate,
@@ -892,9 +1017,160 @@ export class SyncService {
       results.push(result);
     }
 
+    await this.projectTypedEdges(collection, store, options);
+
     return results;
   }
 
+  private async projectTypedEdges(
+    collection: Collection,
+    store: StorePort,
+    options: SyncOptions
+  ): Promise<Array<{ relPath: string; code: string; message: string }>> {
+    const errors: Array<{ relPath: string; code: string; message: string }> =
+      [];
+
+    const backfillResult = await store.backfillDocEdges();
+    if (!backfillResult.ok) {
+      return [
+        {
+          relPath: "(typed edge backfill)",
+          code: backfillResult.error.code,
+          message: backfillResult.error.message,
+        },
+      ];
+    }
+
+    const docsResult = await store.listDocuments();
+    if (!docsResult.ok) {
+      return [
+        {
+          relPath: "(typed edge projection)",
+          code: docsResult.error.code,
+          message: docsResult.error.message,
+        },
+      ];
+    }
+
+    const activeDocs = docsResult.value.filter((doc) => doc.active);
+
+    for (const doc of activeDocs) {
+      if (!doc.mirrorHash) {
+        continue;
+      }
+
+      const contentResult = await store.getContent(doc.mirrorHash);
+      if (!contentResult.ok || contentResult.value === null) {
+        continue;
+      }
+
+      const relationsValue = parseFrontmatter(contentResult.value).metadata
+        .relations;
+      const relationEdges: DocEdgeInput[] = [];
+
+      if (isRelationMap(relationsValue)) {
+        for (const [rawEdgeType, targets] of Object.entries(relationsValue)) {
+          const edgeType = normalizeRelationEdgeType(rawEdgeType);
+          if (!RELATION_EDGE_TYPE_PATTERN.test(edgeType)) {
+            continue;
+          }
+          for (const target of targets) {
+            const targetDoc = resolveRelationTarget(activeDocs, doc, target);
+            if (targetDoc) {
+              relationEdges.push({
+                targetDocId: targetDoc.id,
+                edgeType,
+                confidence: "manual",
+              });
+            }
+          }
+        }
+      }
+      const relationTargetIds = new Set(
+        relationEdges.map((edge) => edge.targetDocId)
+      );
+
+      const relationsResult = await store.setDocEdges(
+        doc.id,
+        relationEdges,
+        "frontmatter-relation"
+      );
+      if (!relationsResult.ok) {
+        errors.push({
+          relPath: doc.relPath,
+          code: relationsResult.error.code,
+          message: relationsResult.error.message,
+        });
+      }
+
+      const primaryHint = getPrimaryGraphHint(
+        doc.contentType,
+        options.contentTypeRules ?? []
+      );
+      if (!primaryHint || !RELATION_EDGE_TYPE_PATTERN.test(primaryHint)) {
+        continue;
+      }
+
+      const linksResult = await store.getLinksForDoc(doc.id);
+      if (!linksResult.ok) {
+        errors.push({
+          relPath: doc.relPath,
+          code: linksResult.error.code,
+          message: linksResult.error.message,
+        });
+        continue;
+      }
+
+      const wikiEdges: DocEdgeInput[] = [];
+      const markdownEdges: DocEdgeInput[] = [];
+      for (const link of linksResult.value) {
+        const targetRef =
+          link.linkType === "markdown"
+            ? `${doc.collection}/${link.targetRefNorm}`
+            : link.targetCollection
+              ? `${link.targetCollection}:${link.targetRef}`
+              : link.targetRefNorm;
+        const targetDoc = resolveRelationTarget(activeDocs, doc, targetRef);
+        if (!targetDoc || relationTargetIds.has(targetDoc.id)) {
+          continue;
+        }
+        const edge = {
+          targetDocId: targetDoc.id,
+          edgeType: primaryHint,
+          confidence: "configured" as const,
+        };
+        if (link.linkType === "wiki") {
+          wikiEdges.push(edge);
+        } else {
+          markdownEdges.push(edge);
+        }
+      }
+
+      const wikiResult = await store.setDocEdges(doc.id, wikiEdges, "wikilink");
+      if (!wikiResult.ok) {
+        errors.push({
+          relPath: doc.relPath,
+          code: wikiResult.error.code,
+          message: wikiResult.error.message,
+        });
+      }
+      const markdownResult = await store.setDocEdges(
+        doc.id,
+        markdownEdges,
+        "markdown-link"
+      );
+      if (!markdownResult.ok) {
+        errors.push({
+          relPath: doc.relPath,
+          code: markdownResult.error.code,
+          message: markdownResult.error.message,
+        });
+      }
+    }
+
+    return errors;
+  }
+
   /**
    * Sync a single collection.
    */
@@ -1121,6 +1397,10 @@ export class SyncService {
       }
     }
 
+    errors.push(
+      ...(await this.projectTypedEdges(collection, store, syncOptions))
+    );
+
     return {
       collection: collection.name,
       filesProcessed: entries.length,