@gmickel/gno 1.8.0 → 1.9.0

package/src/ingestion/frontmatter.ts

@@ -117,6 +117,78 @@ function parseTagsValue(
   return [];
 }
 
+function parseInlineArrayValue(value: string): string[] | undefined {
+  const inlineMatch = INLINE_ARRAY_REGEX.exec(value.trim());
+  if (!inlineMatch) {
+    return undefined;
+  }
+  const rawItems = inlineMatch[1];
+  if (rawItems === undefined) {
+    return [];
+  }
+
+  return rawItems
+    .split(",")
+    .map((item) => unquoteScalar(item.trim()))
+    .filter((item) => item.length > 0);
+}
+
+function unquoteScalar(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) {
+    return trimmed;
+  }
+  const first = trimmed[0];
+  const last = trimmed.at(-1);
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+
+function parseBlockArrayValue(lines: string[], startIdx: number): string[] {
+  const items: string[] = [];
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === undefined) break;
+    const itemMatch = YAML_ARRAY_ITEM_REGEX.exec(line);
+    if (itemMatch?.[1]) {
+      const item = unquoteScalar(itemMatch[1]);
+      if (item.length > 0) {
+        items.push(item);
+      }
+      continue;
+    }
+    if (
+      line.trim().length > 0 &&
+      !line.startsWith(" ") &&
+      !line.startsWith("\t")
+    ) {
+      break;
+    }
+  }
+  return items;
+}
+
+function parseMetadataValue(
+  value: string,
+  lines: string[],
+  startIdx: number
+): string | string[] | undefined {
+  const trimmed = value.trim();
+  const inlineArray = parseInlineArrayValue(trimmed);
+  if (inlineArray) {
+    return inlineArray;
+  }
+
+  if (trimmed.length === 0) {
+    const blockArray = parseBlockArrayValue(lines, startIdx);
+    return blockArray.length > 0 ? blockArray : undefined;
+  }
+
+  return unquoteScalar(trimmed);
+}
+
 /**
  * Parse frontmatter from markdown source.
  * Returns extracted tags and metadata.
@@ -170,8 +242,11 @@ export function parseFrontmatter(source: string): FrontmatterResult {
       if (colonIdx > 0) {
         const key = line.slice(0, colonIdx).trim();
         const value = line.slice(colonIdx + 1).trim();
-        if (key !== "tags" && value.length > 0) {
-          result.metadata[key] = value;
+        if (key !== "tags") {
+          const metadataValue = parseMetadataValue(value, lines, i);
+          if (metadataValue !== undefined) {
+            result.metadata[key] = metadataValue;
+          }
         }
       }
     }

package/src/ingestion/index.ts

@@ -10,12 +10,14 @@ export { defaultChunker, MarkdownChunker } from "./chunker";
 export { defaultLanguageDetector, SimpleLanguageDetector } from "./language";
 // Sync service
 export { defaultSyncService, SyncService } from "./sync";
+export { resolveContentTypeRules, withContentTypeRules } from "./sync-options";
 // Types
 export type {
   ChunkerPort,
   ChunkOutput,
   ChunkParams,
   CollectionSyncResult,
+  ContentTypeSource,
   FileSyncResult,
   FileSyncStatus,
   LanguageDetectorPort,

package/src/ingestion/sync-options.ts

@@ -0,0 +1,29 @@
+/**
+ * Sync option helpers.
+ *
+ * @module src/ingestion/sync-options
+ */
+
+import type { Config, NormalizedContentTypeRule } from "../config";
+import type { SyncOptions } from "./types";
+
+import { fingerprintContentTypeRules, normalizeContentTypes } from "../config";
+
+export function resolveContentTypeRules(
+  config?: Pick<Config, "contentTypes">
+): NormalizedContentTypeRule[] {
+  return normalizeContentTypes(config?.contentTypes ?? []).rules;
+}
+
+export function withContentTypeRules(
+  options: SyncOptions = {},
+  config?: Pick<Config, "contentTypes">
+): SyncOptions {
+  const rules = options.contentTypeRules ?? resolveContentTypeRules(config);
+  return {
+    ...options,
+    contentTypeRules: rules,
+    contentTypeRulesFingerprint:
+      options.contentTypeRulesFingerprint ?? fingerprintContentTypeRules(rules),
+  };
+}

package/src/ingestion/sync.ts

@@ -10,6 +10,7 @@ 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,
@@ -22,6 +23,7 @@ import type {
 import type {
   ChunkerPort,
   CollectionSyncResult,
+  ContentTypeSource,
   FileSyncResult,
   ProcessDecision,
   SyncOptions,
@@ -30,6 +32,7 @@ import type {
   WalkerPort,
 } from "./types";
 
+import { fingerprintContentTypeRules } from "../config";
 import { getDefaultMimeDetector, type MimeDetector } from "../converters/mime";
 import {
   type ConversionPipeline,
@@ -68,6 +71,7 @@ const MAX_CONCURRENCY = 16;
  * Documents with ingestVersion < INGEST_VERSION will be re-processed.
  */
 export const INGEST_VERSION = 5;
+const EMPTY_CONTENT_TYPE_RULES_FINGERPRINT = fingerprintContentTypeRules([]);
 
 /**
  * Decide whether to process a file or skip it.
@@ -76,7 +80,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 +113,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 +158,7 @@ function extractTags(markdown: string): string[] {
 
 interface DocumentMetadata {
   contentType?: string;
+  contentTypeSource: ContentTypeSource;
   categories?: string[];
   author?: string;
   frontmatterDate?: string;
@@ -210,47 +226,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;
+  }
+  const first = trimmed[0];
+  const last = trimmed.at(-1);
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return trimmed.slice(1, -1).trim();
   }
-  return "prose";
+  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 +363,7 @@ function extractDocumentMetadata(
 
   return {
     contentType,
+    contentTypeSource,
     categories: [...categories],
     author,
     frontmatterDate,
@@ -488,6 +553,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 +564,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 +638,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
@@ -588,6 +662,7 @@ export class SyncService {
         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 +786,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";
@@ -828,6 +905,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 +976,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 +990,9 @@ export class SyncService {
               collection,
               entry,
               store,
-              options
+              syncOptions
             );
+            fileResults.push(result);
             switch (result.status) {
               case "added":
                 added += 1;
@@ -970,8 +1056,9 @@ export class SyncService {
               collection,
               entry,
               store,
-              options
+              syncOptions
             );
+            fileResults.push(result);
             results.push(result);
           } finally {
             semaphore.release();
@@ -1044,6 +1131,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/index-cmd.ts

@@ -12,7 +12,7 @@ import { acquireWriteLock, type WriteLockHandle } from "../../core/file-lock";
 import { JobError } from "../../core/job-manager";
 import { normalizeCollectionName } from "../../core/validation";
 import { embedBacklog } from "../../embed";
-import { defaultSyncService } from "../../ingestion";
+import { defaultSyncService, withContentTypeRules } from "../../ingestion";
 import { LlmAdapter } from "../../llm/nodeLlamaCpp/adapter";
 import { resolveModelUri } from "../../llm/registry";
 import {
@@ -95,11 +95,14 @@ export function handleIndex(
           ? [collection.name]
           : ctx.collections.map((entry) => entry.name);
 
-        const options = {
-          gitPull: args.gitPull ?? false,
-          // Security: MCP never runs updateCmd by default
-          runUpdateCmd: false,
-        };
+        const options = withContentTypeRules(
+          {
+            gitPull: args.gitPull ?? false,
+            // Security: MCP never runs updateCmd by default
+            runUpdateCmd: false,
+          },
+          ctx.config
+        );
 
         const modelUri = resolveModelUri(
           ctx.config,
@@ -203,7 +206,10 @@ export function handleIndex(
           collections,
           status: "started",
           phases: ["sync", "embed"],
-          options,
+          options: {
+            gitPull: options.gitPull ?? false,
+            runUpdateCmd: options.runUpdateCmd ?? false,
+          },
         };
 
         return result;

package/src/mcp/tools/index.ts

@@ -11,6 +11,7 @@ import { z } from "zod";
 import type { ToolContext } from "../server";
 
 import { CAPTURE_MAX_TEXT_BYTES } from "../../core/capture";
+import { NOTE_PRESETS, type NotePresetId } from "../../core/note-presets";
 import { normalizeTag } from "../../core/tags";
 import { handleAddCollection } from "./add-collection";
 import { handleCapture } from "./capture";
@@ -142,7 +143,12 @@ const searchInputSchema = z.object({
     .describe("Require ANY of these tags (OR filter)"),
 });
 
-const captureInputSchema = z.object({
+const notePresetIds = NOTE_PRESETS.map((preset) => preset.id) as [
+  NotePresetId,
+  ...NotePresetId[],
+];
+
+export const captureInputSchema = z.object({
   collection: z
     .string()
     .min(1, "Collection cannot be empty")
@@ -173,14 +179,7 @@ const captureInputSchema = z.object({
     .optional()
     .describe("How to handle name collisions"),
   presetId: z
-    .enum([
-      "blank",
-      "project-note",
-      "research-note",
-      "decision-note",
-      "prompt-pattern",
-      "source-summary",
-    ])
+    .enum(notePresetIds)
     .optional()
     .describe("Optional note preset scaffold"),
   overwrite: z

package/src/mcp/tools/sync.ts

@@ -12,7 +12,7 @@ import { MCP_ERRORS } from "../../core/errors";
 import { acquireWriteLock, type WriteLockHandle } from "../../core/file-lock";
 import { JobError } from "../../core/job-manager";
 import { normalizeCollectionName } from "../../core/validation";
-import { defaultSyncService } from "../../ingestion";
+import { defaultSyncService, withContentTypeRules } from "../../ingestion";
 import { runTool, type ToolResult } from "./index";
 
 interface SyncInput {
@@ -101,10 +101,13 @@ export function handleSync(
           ? [collection.name]
           : ctx.collections.map((entry) => entry.name);
 
-        const options = {
-          gitPull: args.gitPull ?? false,
-          runUpdateCmd: args.runUpdateCmd ?? false,
-        };
+        const options = withContentTypeRules(
+          {
+            gitPull: args.gitPull ?? false,
+            runUpdateCmd: args.runUpdateCmd ?? false,
+          },
+          ctx.config
+        );
 
         const jobId = await ctx.jobManager.startJobWithLock(
           "sync",
@@ -133,7 +136,10 @@ export function handleSync(
           jobId,
           collections,
           status: "started",
-          options,
+          options: {
+            gitPull: options.gitPull ?? false,
+            runUpdateCmd: options.runUpdateCmd ?? false,
+          },
         };
 
         return result;

package/src/mcp/tools/workspace-write.ts

@@ -27,7 +27,7 @@ import {
   planMoveRefactor,
   planRenameRefactor,
 } from "../../core/file-refactors";
-import { defaultSyncService } from "../../ingestion";
+import { defaultSyncService, withContentTypeRules } from "../../ingestion";
 import { runTool, type ToolResult } from "./index";
 
 interface CreateFolderInput {
@@ -210,9 +210,11 @@ export function handleRenameNote(
         const currentPath = join(collection.path, doc.relPath);
         const nextPath = join(collection.path, plan.nextRelPath);
         await renameFilePath(currentPath, nextPath);
-        await defaultSyncService.syncCollection(collection, ctx.store, {
-          runUpdateCmd: false,
-        });
+        await defaultSyncService.syncCollection(
+          collection,
+          ctx.store,
+          withContentTypeRules({ runUpdateCmd: false }, ctx.config)
+        );
         return {
           uri: plan.nextUri,
           relPath: plan.nextRelPath,
@@ -253,9 +255,11 @@ export function handleMoveNote(
         const nextPath = join(collection.path, plan.nextRelPath);
         await mkdir(dirname(nextPath), { recursive: true });
         await renameFilePath(currentPath, nextPath);
-        await defaultSyncService.syncCollection(collection, ctx.store, {
-          runUpdateCmd: false,
-        });
+        await defaultSyncService.syncCollection(
+          collection,
+          ctx.store,
+          withContentTypeRules({ runUpdateCmd: false }, ctx.config)
+        );
         return {
           uri: plan.nextUri,
           relPath: plan.nextRelPath,
@@ -304,9 +308,11 @@ export function handleDuplicateNote(
         const nextPath = join(collection.path, plan.nextRelPath);
         await mkdir(dirname(nextPath), { recursive: true });
         await copyFilePath(currentPath, nextPath);
-        await defaultSyncService.syncCollection(collection, ctx.store, {
-          runUpdateCmd: false,
-        });
+        await defaultSyncService.syncCollection(
+          collection,
+          ctx.store,
+          withContentTypeRules({ runUpdateCmd: false }, ctx.config)
+        );
         return {
           uri: plan.nextUri,
           relPath: plan.nextRelPath,