@gmickel/gno 1.7.1 → 1.9.0

package/src/core/config-mutation.ts

@@ -7,7 +7,12 @@
 import type { Config } from "../config/types";
 import type { SqliteAdapter } from "../store/sqlite/adapter";
 
-import { loadConfig, saveConfig } from "../config";
+import {
+  formatConfigWarnings,
+  loadConfig,
+  normalizeConfigContentTypes,
+  saveConfig,
+} from "../config";
 
 export interface ConfigMutationContext {
   store: SqliteAdapter;
@@ -53,6 +58,9 @@ export async function applyConfigChange<T = void>(
         code: "LOAD_ERROR",
       };
     }
+    for (const warning of formatConfigWarnings(loadResult.warnings)) {
+      console.warn(warning);
+    }
 
     const mutationResult = await mutate(loadResult.value);
     if (!mutationResult.ok) {
@@ -63,7 +71,11 @@ export async function applyConfigChange<T = void>(
       };
     }
 
-    const newConfig = mutationResult.config;
+    const normalized = normalizeConfigContentTypes(mutationResult.config);
+    for (const warning of formatConfigWarnings(normalized.warnings)) {
+      console.warn(warning);
+    }
+    const newConfig = normalized.config;
     const saveResult = await saveConfig(newConfig, ctx.configPath);
     if (!saveResult.ok) {
       return {

package/src/core/file-ops.ts

@@ -4,8 +4,8 @@
  * @module src/core/file-ops
  */
 
-// node:fs/promises for rename/unlink (no Bun equivalent for structure ops)
-import { copyFile, mkdir, rename, unlink } from "node:fs/promises";
+// node:fs/promises for rename/unlink/link (no Bun equivalent for structure ops or exclusive hard-link create)
+import { copyFile, link, mkdir, rename, unlink } from "node:fs/promises";
 // node:os platform/homedir/tmpdir: no Bun equivalent
 import { homedir, platform as getPlatform, tmpdir } from "node:os";
 // node:path dirname/join/parse: no Bun equivalent
@@ -27,6 +27,25 @@ export async function atomicWrite(
   }
 }
 
+export async function atomicCreate(
+  path: string,
+  content: string
+): Promise<void> {
+  const tempPath = `${path}.tmp.${crypto.randomUUID()}`;
+  await Bun.write(tempPath, content);
+  try {
+    await link(tempPath, path);
+  } catch (e) {
+    await unlink(tempPath).catch(() => {
+      /* ignore cleanup errors */
+    });
+    throw e;
+  }
+  await unlink(tempPath).catch(() => {
+    /* ignore cleanup errors */
+  });
+}
+
 async function runCommand(cmd: string[]): Promise<void> {
   const proc = Bun.spawn({
     cmd,

package/src/core/note-presets.ts

@@ -14,7 +14,11 @@ export type NotePresetId =
   | "research-note"
   | "decision-note"
   | "prompt-pattern"
-  | "source-summary";
+  | "source-summary"
+  | "idea-original"
+  | "person"
+  | "company-project"
+  | "meeting";
 
 export interface NotePresetDefinition {
   id: NotePresetId;
@@ -104,14 +108,14 @@ export const NOTE_PRESETS: NotePresetDefinition[] = [
   {
     id: "decision-note",
     label: "Decision Note",
-    description: "Context, decision, rationale, and consequences.",
+    description: "Current synthesis, decision, rationale, and timeline.",
     defaultTags: ["decision"],
     frontmatter: {
       category: "decision",
       status: "proposed",
     },
     body: (title) =>
-      `# ${title}\n\n## Context\n\n## Decision\n\n## Rationale\n\n## Consequences\n`,
+      `# ${title}\n\n## Current Synthesis\n\n## Decision\n\n## Rationale\n\n## Consequences\n\n## Timeline\n`,
   },
   {
     id: "prompt-pattern",
@@ -127,14 +131,66 @@ export const NOTE_PRESETS: NotePresetDefinition[] = [
   {
     id: "source-summary",
     label: "Source Summary",
-    description: "Summarize an article, paper, or external source cleanly.",
+    description: "Summarize a source with synthesis above evidence timeline.",
     defaultTags: ["source", "summary"],
     frontmatter: {
       category: "source-summary",
       sources: [],
     },
     body: (title) =>
-      `# ${title}\n\n## Summary\n\n## Important Claims\n\n## Evidence / Quotes\n\n## Takeaways\n`,
+      `# ${title}\n\n## Current Synthesis\n\n## Important Claims\n\n## Assessment\n\n## Timeline\n\n## Evidence / Quotes\n`,
+  },
+  {
+    id: "idea-original",
+    label: "Original Idea",
+    description:
+      "Capture exact phrasing, context, related concepts, and publish potential.",
+    frontmatter: {
+      type: "idea-original",
+      category: "idea-original",
+      tags: [],
+    },
+    body: (title) =>
+      `# ${title}\n\n## Current Synthesis\n\n## Open Threads\n\n## Assessment\n\n## Timeline\n\n## Exact Phrasing\n\n## Related Concepts\n`,
+  },
+  {
+    id: "person",
+    label: "Person",
+    description:
+      "Track current state, relationship, assessment, open threads, and timeline.",
+    frontmatter: {
+      type: "person",
+      category: "person",
+      tags: [],
+    },
+    body: (title) =>
+      `# ${title}\n\n## Current Synthesis\n\n## Open Threads\n\n## Assessment\n\n## Timeline\n\n## Relationship\n`,
+  },
+  {
+    id: "company-project",
+    label: "Company / Project",
+    description:
+      "Track state, changes, decisions, people, open threads, and timeline.",
+    frontmatter: {
+      type: "company-project",
+      category: "company-project",
+      tags: [],
+    },
+    body: (title) =>
+      `# ${title}\n\n## Current Synthesis\n\n## Open Threads\n\n## Assessment\n\n## Timeline\n\n## Decisions\n\n## People\n`,
+  },
+  {
+    id: "meeting",
+    label: "Meeting",
+    description:
+      "Put analysis above the timeline; keep transcript, notes, and actions below.",
+    frontmatter: {
+      type: "meeting",
+      category: "meeting",
+      tags: [],
+    },
+    body: (title) =>
+      `# ${title}\n\n## Current Synthesis\n\n## Open Threads\n\n## Assessment\n\n## Timeline\n\n## Transcript / Notes\n\n## Action Items\n`,
   },
 ];
 

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 {