@gmickel/gno 1.8.0 → 1.10.0

package/src/ingestion/sync.ts

@@ -10,9 +10,11 @@ import { stat } from "node:fs/promises";
 // node:path for join (no Bun path utils)
 import { join } from "node:path";
 
+import type { NormalizedContentTypeRule } from "../config";
 import type { Collection } from "../config/types";
 import type {
   ChunkInput,
+  DocEdgeInput,
   DocLinkInput,
   DocumentRow,
   IngestErrorInput,
@@ -22,6 +24,7 @@ import type {
 import type {
   ChunkerPort,
   CollectionSyncResult,
+  ContentTypeSource,
   FileSyncResult,
   ProcessDecision,
   SyncOptions,
@@ -30,6 +33,7 @@ import type {
   WalkerPort,
 } from "./types";
 
+import { fingerprintContentTypeRules } from "../config";
 import { getDefaultMimeDetector, type MimeDetector } from "../converters/mime";
 import {
   type ConversionPipeline,
@@ -40,6 +44,7 @@ import {
   normalizeMarkdownPath,
   normalizeWikiName,
   parseLinks,
+  parseTargetParts,
 } from "../core/links";
 import { normalizeTag, validateTag } from "../core/tags";
 import { defaultChunker } from "./chunker";
@@ -67,7 +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.
@@ -76,7 +204,8 @@ export const INGEST_VERSION = 5;
  */
 function decideAction(
   existing: DocumentRow | null,
-  sourceHash: string
+  sourceHash: string,
+  contentTypeRulesFingerprint: string
 ): ProcessDecision {
   // No existing doc - must process
   if (!existing) {
@@ -108,6 +237,16 @@ function decideAction(
     return { kind: "repair", reason: "ingest version outdated" };
   }
 
+  const hasLegacyEmptyRulesFingerprint =
+    existing.contentTypeRulesFingerprint === null &&
+    contentTypeRulesFingerprint === EMPTY_CONTENT_TYPE_RULES_FINGERPRINT;
+  if (
+    existing.contentTypeRulesFingerprint !== contentTypeRulesFingerprint &&
+    !hasLegacyEmptyRulesFingerprint
+  ) {
+    return { kind: "repair", reason: "content type rules changed" };
+  }
+
   // All good - skip
   return { kind: "skip", reason: "unchanged" };
 }
@@ -143,6 +282,7 @@ function extractTags(markdown: string): string[] {
 
 interface DocumentMetadata {
   contentType?: string;
+  contentTypeSource: ContentTypeSource;
   categories?: string[];
   author?: string;
   frontmatterDate?: string;
@@ -210,47 +350,95 @@ function normalizeDate(value: unknown): string | undefined {
   return parsed.toISOString();
 }
 
-function inferContentType(relPath: string, ext: string): string {
+function inferPathContentType(
+  relPath: string,
+  ext: string
+): {
+  contentType: string;
+  source: ContentTypeSource;
+} {
   const lowerPath = relPath.toLowerCase();
   if (CODE_EXTENSIONS.has(ext.toLowerCase())) {
-    return "code";
+    return { contentType: "code", source: "path-ext" };
   }
   if (/(meeting|standup|retro|minutes)/.test(lowerPath)) {
-    return "meeting";
+    return { contentType: "meeting", source: "path-ext" };
   }
   if (/(spec|rfc|adr|design)/.test(lowerPath)) {
-    return "spec";
+    return { contentType: "spec", source: "path-ext" };
   }
   if (/(notes|journal|log)/.test(lowerPath)) {
-    return "notes";
+    return { contentType: "notes", source: "path-ext" };
+  }
+  return { contentType: "prose", source: "fallback" };
+}
+
+function normalizeFrontmatterScalar(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) {
+    return trimmed;
   }
-  return "prose";
+  const first = trimmed[0];
+  const last = trimmed.at(-1);
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
 }
 
 function parseCategories(input: unknown): string[] {
   if (Array.isArray(input)) {
     return input
       .filter((v): v is string => typeof v === "string")
-      .map((v) => v.trim().toLowerCase())
+      .map((v) => normalizeFrontmatterScalar(v).toLowerCase())
       .filter((v) => v.length > 0);
   }
   if (typeof input === "string") {
     return input
       .split(",")
-      .map((v) => v.trim().toLowerCase())
+      .map((v) => normalizeFrontmatterScalar(v).toLowerCase())
       .filter((v) => v.length > 0);
   }
   return [];
 }
 
-function extractDocumentMetadata(
+function matchPrefixContentType(
+  relPath: string,
+  rules: NormalizedContentTypeRule[]
+): string | undefined {
+  for (const rule of rules) {
+    if (rule.prefixes.some((prefix) => relPath.startsWith(prefix))) {
+      return rule.id;
+    }
+  }
+  return undefined;
+}
+
+export function extractDocumentMetadata(
   markdown: string,
   relPath: string,
-  ext: string
+  ext: string,
+  contentTypeRules: NormalizedContentTypeRule[] = []
 ): DocumentMetadata {
   const parsed = parseFrontmatter(markdown);
   const metadata = parsed.metadata;
-  const contentType = inferContentType(relPath, ext);
+  const typedRules = new Map(contentTypeRules.map((rule) => [rule.id, rule]));
+  const rawFrontmatterType =
+    typeof metadata.type === "string"
+      ? normalizeFrontmatterScalar(metadata.type)
+      : "";
+  const frontmatterType = typedRules.get(rawFrontmatterType)?.id;
+  const prefixType =
+    frontmatterType === undefined
+      ? matchPrefixContentType(relPath, contentTypeRules)
+      : undefined;
+  const inferred = inferPathContentType(relPath, ext);
+  const contentType = frontmatterType ?? prefixType ?? inferred.contentType;
+  const contentTypeSource: ContentTypeSource = frontmatterType
+    ? "frontmatter-type"
+    : prefixType
+      ? "prefix"
+      : inferred.source;
   const categories = new Set<string>([contentType]);
 
   const fmCategories = parseCategories(
@@ -299,6 +487,7 @@ function extractDocumentMetadata(
 
   return {
     contentType,
+    contentTypeSource,
     categories: [...categories],
     author,
     frontmatterDate,
@@ -488,6 +677,10 @@ export class SyncService {
       const hasher = new Bun.CryptoHasher("sha256");
       hasher.update(bytes);
       const sourceHash = hasher.digest("hex");
+      const contentTypeRules = options.contentTypeRules ?? [];
+      const contentTypeRulesFingerprint =
+        options.contentTypeRulesFingerprint ??
+        fingerprintContentTypeRules(contentTypeRules);
 
       // 4. Check existing doc for skip/repair decision
       const existingResult = await store.getDocument(
@@ -495,7 +688,11 @@ export class SyncService {
         entry.relPath
       );
       const existing = existingResult.ok ? existingResult.value : null;
-      const decision = decideAction(existing, sourceHash);
+      const decision = decideAction(
+        existing,
+        sourceHash,
+        contentTypeRulesFingerprint
+      );
 
       if (decision.kind === "skip") {
         return { relPath: entry.relPath, status: "unchanged" };
@@ -565,7 +762,8 @@ export class SyncService {
       const extractedMetadata = extractDocumentMetadata(
         artifact.markdown,
         entry.relPath,
-        mime.ext
+        mime.ext,
+        contentTypeRules
       );
 
       // 7. Upsert document - EXPLICITLY clear error fields on success
@@ -584,10 +782,12 @@ 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,
         dateFields: extractedMetadata.dateFields,
+        contentTypeRulesFingerprint,
         // Clear error fields on success (requires store to handle undefined → null)
         lastErrorCode: undefined,
         lastErrorMessage: undefined,
@@ -711,6 +911,8 @@ export class SyncService {
         status,
         docid,
         mirrorHash: artifact.mirrorHash,
+        contentType: extractedMetadata.contentType,
+        contentTypeSource: extractedMetadata.contentTypeSource,
       };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unknown error";
@@ -815,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.
    */
@@ -828,6 +1181,13 @@ export class SyncService {
     options: SyncOptions = {}
   ): Promise<CollectionSyncResult> {
     const startTime = Date.now();
+    const syncOptions: SyncOptions = {
+      ...options,
+      contentTypeRules: options.contentTypeRules ?? [],
+      contentTypeRulesFingerprint:
+        options.contentTypeRulesFingerprint ??
+        fingerprintContentTypeRules(options.contentTypeRules ?? []),
+    };
     const errors: Array<{ relPath: string; code: string; message: string }> =
       [];
 
@@ -892,6 +1252,7 @@ export class SyncService {
     let unchanged = 0;
     let errored = 0;
     let dynamicSkipped = 0;
+    const fileResults: FileSyncResult[] = [];
 
     if (concurrency === 1) {
       // Sequential processing with batched transactions (Windows perf)
@@ -905,8 +1266,9 @@ export class SyncService {
               collection,
               entry,
               store,
-              options
+              syncOptions
             );
+            fileResults.push(result);
             switch (result.status) {
               case "added":
                 added += 1;
@@ -970,8 +1332,9 @@ export class SyncService {
               collection,
               entry,
               store,
-              options
+              syncOptions
             );
+            fileResults.push(result);
             results.push(result);
           } finally {
             semaphore.release();
@@ -1034,6 +1397,10 @@ export class SyncService {
       }
     }
 
+    errors.push(
+      ...(await this.projectTypedEdges(collection, store, syncOptions))
+    );
+
     return {
       collection: collection.name,
       filesProcessed: entries.length,
@@ -1044,6 +1411,7 @@ export class SyncService {
       filesSkipped: skipped.length + dynamicSkipped,
       filesMarkedInactive: markedInactive,
       durationMs: Date.now() - startTime,
+      files: fileResults,
       errors,
     };
   }

package/src/ingestion/types.ts

@@ -5,6 +5,7 @@
  * @module src/ingestion/types
  */
 
+import type { NormalizedContentTypeRule } from "../config";
 import type { Collection } from "../config/types";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -132,8 +133,18 @@ export interface SyncOptions {
    * SQLite operations are serialized regardless of this setting.
    */
   concurrency?: number;
+  /** Normalized content type rules from config.contentTypes. */
+  contentTypeRules?: NormalizedContentTypeRule[];
+  /** Stable hash of the normalized content type rules, used for re-derivation. */
+  contentTypeRulesFingerprint?: string;
 }
 
+export type ContentTypeSource =
+  | "frontmatter-type"
+  | "prefix"
+  | "path-ext"
+  | "fallback";
+
 /** Per-file sync status */
 export type FileSyncStatus =
   | "added"
@@ -148,6 +159,8 @@ export interface FileSyncResult {
   status: FileSyncStatus;
   docid?: string;
   mirrorHash?: string;
+  contentType?: string;
+  contentTypeSource?: ContentTypeSource;
   errorCode?: string;
   errorMessage?: string;
 }
@@ -163,6 +176,7 @@ export interface CollectionSyncResult {
   filesSkipped: number;
   filesMarkedInactive: number;
   durationMs: number;
+  files?: FileSyncResult[];
   errors: Array<{
     relPath: string;
     code: string;

package/src/mcp/tools/add-collection.ts

@@ -18,7 +18,7 @@ import {
   normalizeCollectionName,
   validateCollectionRoot,
 } from "../../core/validation";
-import { defaultSyncService } from "../../ingestion";
+import { defaultSyncService, withContentTypeRules } from "../../ingestion";
 import { runTool, type ToolResult } from "./index";
 
 interface AddCollectionInput {
@@ -147,10 +147,13 @@ export function handleAddCollection(
             const result = await defaultSyncService.syncCollection(
               collection,
               ctx.store,
-              {
-                gitPull: args.gitPull ?? false,
-                runUpdateCmd: false,
-              }
+              withContentTypeRules(
+                {
+                  gitPull: args.gitPull ?? false,
+                  runUpdateCmd: false,
+                },
+                ctx.config
+              )
             );
 
             return {

package/src/mcp/tools/capture.ts

@@ -24,7 +24,7 @@ import { writeCapturePlanFile } from "../../core/capture-write";
 import { MCP_ERRORS } from "../../core/errors";
 import { withWriteLock } from "../../core/file-lock";
 import { normalizeCollectionName } from "../../core/validation";
-import { defaultSyncService } from "../../ingestion";
+import { defaultSyncService, withContentTypeRules } from "../../ingestion";
 import { runTool, type ToolResult } from "./index";
 
 interface CaptureInput extends Omit<
@@ -176,7 +176,10 @@ export function handleCapture(
           collection,
           ctx.store,
           [plan.relPath],
-          { runUpdateCmd: false, gitPull: false }
+          withContentTypeRules(
+            { runUpdateCmd: false, gitPull: false },
+            ctx.config
+          )
         );
         const syncResult = results[0];
         if (!syncResult) {

package/src/mcp/tools/get.ts

@@ -10,11 +10,11 @@ import type { DocumentRow, StorePort } from "../../store/types";
 import type { ToolContext } from "../server";
 
 import { decorateUriForIndex, parseUri } from "../../app/constants";
-import { parseRef } from "../../cli/commands/ref-parser";
 import {
   getDocumentCapabilities,
   type DocumentCapabilities,
 } from "../../core/document-capabilities";
+import { parseRef } from "../../core/ref-parser";
 import { runTool, type ToolResult } from "./index";
 
 interface GetInput {