@gmickel/gno 1.7.1 → 1.9.0

package/src/mcp/tools/capture.ts

@@ -9,54 +9,39 @@ import { mkdir } from "node:fs/promises";
 // node:path for path utils (no Bun path utils)
 import { dirname, extname, join } from "node:path";
 
+import type { NoteCollisionPolicy } from "../../core/note-creation";
+import type { NotePresetId } from "../../core/note-presets";
 import type { ToolContext } from "../server";
 
-import { buildUri } from "../../app/constants";
+import {
+  buildCaptureReceipt,
+  listCaptureDiskRelPaths,
+  planCapture,
+  type CaptureInput as SharedCaptureInput,
+  type CaptureReceipt,
+} from "../../core/capture";
+import { writeCapturePlanFile } from "../../core/capture-write";
 import { MCP_ERRORS } from "../../core/errors";
 import { withWriteLock } from "../../core/file-lock";
-import { atomicWrite } from "../../core/file-ops";
-import {
-  resolveNoteCreatePlan,
-  type NoteCollisionPolicy,
-} from "../../core/note-creation";
-import {
-  getNotePreset,
-  resolveNotePreset,
-  type NotePresetId,
-} from "../../core/note-presets";
-import { normalizeTag, validateTag } from "../../core/tags";
-import {
-  normalizeCollectionName,
-  validateRelPath,
-} from "../../core/validation";
-import { defaultSyncService } from "../../ingestion";
-import { updateFrontmatterTags } from "../../ingestion/frontmatter";
-import { extractTitle } from "../../pipeline/contextual";
+import { normalizeCollectionName } from "../../core/validation";
+import { defaultSyncService, withContentTypeRules } from "../../ingestion";
 import { runTool, type ToolResult } from "./index";
 
-interface CaptureInput {
-  collection: string;
-  content?: string;
-  title?: string;
+interface CaptureInput extends Omit<
+  SharedCaptureInput,
+  "relPath" | "collisionPolicy" | "presetId"
+> {
   path?: string;
-  overwrite?: boolean;
-  folderPath?: string;
   collisionPolicy?: NoteCollisionPolicy;
   presetId?: NotePresetId;
-  tags?: string[];
 }
 
-interface CaptureResult {
+type McpCaptureResult = CaptureReceipt & {
   docid: string;
-  uri: string;
   absPath: string;
-  collection: string;
-  relPath: string;
-  created: boolean;
   overwritten: boolean;
   serverInstanceId: string;
-  tags?: string[];
-}
+};
 
 const SENSITIVE_SUBPATHS = new Set([
   ".ssh",
@@ -67,51 +52,56 @@ const SENSITIVE_SUBPATHS = new Set([
   "node_modules",
 ]);
 
-function sanitizeFilename(title: string): string {
-  return title
-    .toLowerCase()
-    .trim()
-    .replaceAll(/[^\w\s-]/g, "")
-    .replaceAll(/\s+/g, "-")
-    .replaceAll(/-+/g, "-")
-    .replace(/^-|-$/g, "");
-}
-
 function ensureMarkdownExtension(relPath: string): string {
   return extname(relPath) ? relPath : `${relPath}.md`;
 }
 
 function assertNotSensitive(relPath: string): void {
-  const firstSegment = relPath.split(/[\\/]/)[0];
-  if (firstSegment && SENSITIVE_SUBPATHS.has(firstSegment)) {
-    throw new Error(
-      `${MCP_ERRORS.INVALID_PATH.code}: Cannot write to sensitive directory: ${firstSegment}`
-    );
+  for (const segment of relPath.split(/[\\/]/)) {
+    if (segment && SENSITIVE_SUBPATHS.has(segment)) {
+      throw new Error(
+        `${MCP_ERRORS.INVALID_PATH.code}: Cannot write to sensitive directory: ${segment}`
+      );
+    }
   }
 }
 
-function generateFilename(title: string | undefined, content: string): string {
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const fallback = `note-${timestamp}.md`;
-  const baseTitle = title?.trim() || extractTitle(content, fallback);
-  const slug = sanitizeFilename(baseTitle);
-  const safeSlug = slug || `note-${timestamp}`;
-  return `${safeSlug}.md`;
-}
-
-function formatCaptureResult(result: CaptureResult): string {
+function formatCaptureResult(result: McpCaptureResult): string {
   const lines: string[] = [];
   lines.push(`Doc: ${result.docid}`);
   lines.push(`URI: ${result.uri}`);
   lines.push(`Path: ${result.absPath}`);
   lines.push(`Created: ${result.created ? "yes" : "no"}`);
+  lines.push(`Opened existing: ${result.openedExisting ? "yes" : "no"}`);
   lines.push(`Overwritten: ${result.overwritten ? "yes" : "no"}`);
-  if (result.tags && result.tags.length > 0) {
+  lines.push(`Collision: ${result.collisionPolicyResult}`);
+  lines.push(`Sync: ${result.sync.status}`);
+  lines.push(`Embed: ${result.embed.status}`);
+  lines.push(`Content hash: ${result.contentHash}`);
+  if (result.tags.length > 0) {
     lines.push(`Tags: ${result.tags.join(", ")}`);
   }
   return lines.join("\n");
 }
 
+function buildSharedInput(
+  args: CaptureInput,
+  collectionName: string
+): SharedCaptureInput {
+  return {
+    collection: collectionName,
+    content: args.content,
+    title: args.title,
+    relPath: args.path ? ensureMarkdownExtension(args.path) : undefined,
+    folderPath: args.folderPath,
+    collisionPolicy: args.collisionPolicy,
+    presetId: args.presetId,
+    tags: args.tags,
+    source: args.source,
+    overwrite: args.overwrite,
+  };
+}
+
 export function handleCapture(
   args: CaptureInput,
   ctx: ToolContext
@@ -135,183 +125,139 @@ export function handleCapture(
           );
         }
 
-        if (args.presetId && !getNotePreset(args.presetId)) {
-          throw new Error(
-            `${MCP_ERRORS.INVALID_INPUT.code}: Unknown presetId: ${args.presetId}`
-          );
-        }
-
         const existingDocs = await ctx.store.listDocuments(collectionName);
         if (!existingDocs.ok) {
           throw new Error(existingDocs.error.message);
         }
 
-        let relPath: string;
+        let plan;
         try {
-          const plan = resolveNoteCreatePlan(
-            {
-              collection: collection.name,
-              relPath: args.path
-                ? ensureMarkdownExtension(validateRelPath(args.path))
-                : undefined,
-              title:
-                args.title?.trim() ||
-                generateFilename(args.title, args.content ?? "").replace(
-                  /\.md$/u,
-                  ""
-                ),
-              folderPath: args.folderPath,
-              collisionPolicy: args.collisionPolicy,
-            },
-            existingDocs.value.map((doc) => doc.relPath)
-          );
-          if (plan.openedExisting) {
-            throw new Error(
-              `${MCP_ERRORS.CONFLICT.code}: Existing note resolution is not supported through gno_capture yet`
-            );
-          }
-          relPath = plan.relPath;
+          plan = planCapture({
+            input: buildSharedInput(args, collection.name),
+            existingRelPaths: existingDocs.value.map((doc) => doc.relPath),
+            diskRelPaths: await listCaptureDiskRelPaths(collection.path),
+          });
         } catch (error) {
           const message =
             error instanceof Error ? error.message : String(error);
-          throw new Error(`${MCP_ERRORS.INVALID_PATH.code}: ${message}`);
+          throw new Error(`${MCP_ERRORS.INVALID_INPUT.code}: ${message}`);
         }
 
-        assertNotSensitive(relPath);
+        assertNotSensitive(plan.relPath);
 
-        // Validate and normalize tags
-        let normalizedTags: string[] = [];
-        if (args.tags && args.tags.length > 0) {
-          for (const tag of args.tags) {
-            const normalized = normalizeTag(tag);
-            if (!validateTag(normalized)) {
-              throw new Error(
-                `${MCP_ERRORS.INVALID_INPUT.code}: Invalid tag "${tag}". Tags must be lowercase, alphanumeric with hyphens/dots/slashes.`
-              );
-            }
-            normalizedTags.push(normalized);
-          }
-          // Dedupe
-          normalizedTags = [...new Set(normalizedTags)];
-        }
-
-        const absPath = join(collection.path, relPath);
-        const file = Bun.file(absPath);
-        const exists = await file.exists();
-        if (exists && !args.overwrite) {
-          throw new Error(
-            `${MCP_ERRORS.CONFLICT.code}: File exists: ${relPath}`
-          );
-        }
+        const absPath = join(collection.path, plan.relPath);
+        const existingFile = Bun.file(absPath);
+        const exists = await existingFile.exists();
 
-        // Update frontmatter with tags for Markdown files
-        const resolvedPreset = resolveNotePreset({
-          presetId: args.presetId,
-          title:
-            args.title?.trim() ||
-            relPath
-              .split("/")
-              .pop()
-              ?.replace(/\.[^.]+$/u, "") ||
-            "Untitled",
-          tags: normalizedTags,
-          body: args.content,
-        });
-        let contentToWrite =
-          resolvedPreset?.content ??
-          args.content ??
-          `# ${args.title?.trim() || "Untitled"}\n`;
-        const isMarkdown =
-          relPath.endsWith(".md") || relPath.endsWith(".markdown");
-        if (isMarkdown && normalizedTags.length > 0) {
-          // Use shared utility that handles all frontmatter edge cases
-          contentToWrite = updateFrontmatterTags(
-            contentToWrite,
-            normalizedTags
+        if (plan.openedExisting) {
+          const docResult = await ctx.store.getDocument(
+            collectionName,
+            plan.relPath
           );
+          const existingDoc = docResult.ok ? docResult.value : undefined;
+          return buildCaptureReceipt({
+            plan,
+            absPath,
+            docid: existingDoc?.docid ?? "",
+            sync: {
+              status: existingDoc ? "completed" : "skipped",
+              reason: existingDoc
+                ? "Existing capture already indexed."
+                : "Existing capture opened from disk but is not indexed yet.",
+            },
+            serverInstanceId: ctx.serverInstanceId,
+          }) as McpCaptureResult;
         }
 
         await mkdir(dirname(absPath), { recursive: true });
-        await atomicWrite(absPath, contentToWrite);
+        await writeCapturePlanFile(plan, absPath);
 
         const results = await defaultSyncService.syncFiles(
           collection,
           ctx.store,
-          [relPath],
-          { runUpdateCmd: false, gitPull: false }
+          [plan.relPath],
+          withContentTypeRules(
+            { runUpdateCmd: false, gitPull: false },
+            ctx.config
+          )
         );
         const syncResult = results[0];
         if (!syncResult) {
-          throw new Error("RUNTIME: Sync result missing");
+          return buildCaptureReceipt({
+            plan,
+            absPath,
+            docid: "",
+            sync: {
+              status: "failed",
+              error: "RUNTIME: Sync result missing",
+            },
+            overwritten: exists && args.overwrite === true,
+            serverInstanceId: ctx.serverInstanceId,
+          }) as McpCaptureResult;
         }
         if (syncResult.status === "error") {
-          throw new Error(
-            `INGEST_ERROR: ${syncResult.errorCode ?? "ERROR"} - ${
-              syncResult.errorMessage ?? "Unknown error"
-            }`
-          );
+          return buildCaptureReceipt({
+            plan,
+            absPath,
+            docid: "",
+            sync: {
+              status: "failed",
+              error: `INGEST_ERROR: ${syncResult.errorCode ?? "ERROR"} - ${
+                syncResult.errorMessage ?? "Unknown error"
+              }`,
+            },
+            overwritten: exists && args.overwrite === true,
+            serverInstanceId: ctx.serverInstanceId,
+          }) as McpCaptureResult;
         }
 
         let docid = syncResult.docid;
         let documentId: number | undefined;
-        if (!docid) {
-          const docResult = await ctx.store.getDocument(
-            collectionName,
-            relPath
-          );
-          if (!docResult.ok) {
-            throw new Error(docResult.error.message);
-          }
-          if (!docResult.value) {
-            throw new Error("RUNTIME: Document missing after sync");
-          }
-          docid = docResult.value.docid;
+        const docResult = await ctx.store.getDocument(
+          collectionName,
+          plan.relPath
+        );
+        if (docResult.ok && docResult.value) {
+          docid = docid ?? docResult.value.docid;
           documentId = docResult.value.id;
-        } else {
-          // Get document id for tag storage
-          const docResult = await ctx.store.getDocument(
-            collectionName,
-            relPath
-          );
-          if (docResult.ok && docResult.value) {
-            documentId = docResult.value.id;
-          }
+        }
+        if (!docid) {
+          return buildCaptureReceipt({
+            plan,
+            absPath,
+            docid: "",
+            sync: {
+              status: "failed",
+              error: "RUNTIME: Document missing after sync",
+            },
+            overwritten: exists && args.overwrite === true,
+            serverInstanceId: ctx.serverInstanceId,
+          }) as McpCaptureResult;
         }
 
-        // For non-markdown files, store tags as user-source in DB
-        // (Markdown files get tags from frontmatter during sync)
-        let tagsStored = isMarkdown; // Markdown tags stored via frontmatter sync
-        if (!isMarkdown && normalizedTags.length > 0 && documentId) {
+        const isMarkdown =
+          plan.relPath.endsWith(".md") || plan.relPath.endsWith(".markdown");
+        if (!isMarkdown && plan.tags.length > 0 && documentId) {
           const tagResult = await ctx.store.setDocTags(
             documentId,
-            normalizedTags,
+            plan.tags,
             "user"
           );
-          if (tagResult.ok) {
-            tagsStored = true;
-          } else {
-            // Log warning - document created but tags not stored
+          if (!tagResult.ok) {
             console.error(
               `[MCP] Warning: Document created but tags not stored: ${tagResult.error.message}`
             );
           }
         }
 
-        // Only include tags in response if confirmed stored
-        const confirmedTags =
-          tagsStored && normalizedTags.length > 0 ? normalizedTags : undefined;
-
-        return {
-          docid,
-          uri: buildUri(collectionName, relPath),
+        return buildCaptureReceipt({
+          plan,
           absPath,
-          collection: collectionName,
-          relPath,
-          created: !exists,
-          overwritten: exists,
+          docid,
+          sync: { status: "completed" },
+          overwritten: exists && args.overwrite === true,
           serverInstanceId: ctx.serverInstanceId,
-          tags: confirmedTags,
-        };
+        }) as McpCaptureResult;
       });
     },
     formatCaptureResult

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

@@ -10,6 +10,8 @@ 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";
@@ -141,13 +143,19 @@ 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")
     .describe("Target collection name (must already exist)"),
   content: z
     .string()
+    .max(CAPTURE_MAX_TEXT_BYTES)
     .optional()
     .describe(
       "Document content (markdown or plain text). Optional when presetId provides a scaffold."
@@ -171,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
@@ -189,6 +190,39 @@ const captureInputSchema = z.object({
     .array(z.string())
     .optional()
     .describe("Tags to apply to the new document"),
+  source: z
+    .object({
+      kind: z
+        .enum([
+          "direct",
+          "web",
+          "email",
+          "meeting",
+          "chat",
+          "file",
+          "api",
+          "unknown",
+        ])
+        .optional()
+        .describe("Capture source kind"),
+      title: z.string().optional().describe("Human source title"),
+      url: z.string().optional().describe("Source URL"),
+      uri: z.string().optional().describe("Source URI"),
+      docid: z.string().optional().describe("Source GNO doc ID"),
+      mime: z.string().optional().describe("Source MIME type"),
+      ext: z.string().optional().describe("Source file extension"),
+      author: z.string().optional().describe("Source author"),
+      observedAt: z
+        .string()
+        .optional()
+        .describe("When the source was observed"),
+      capturedAt: z.string().optional().describe("Capture timestamp override"),
+      externalId: z.string().optional().describe("External system/source ID"),
+    })
+    .optional()
+    .describe(
+      "Structured provenance metadata written under source frontmatter"
+    ),
 });
 
 const addCollectionInputSchema = z.object({

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,

package/src/pipeline/hybrid.ts

@@ -841,6 +841,8 @@ export async function searchHybrid(
       score: candidate.blendedScore,
       uri: doc.uri,
       title: doc.title ?? undefined,
+      contentType: doc.contentType ?? undefined,
+      categories: doc.categories ?? undefined,
       line: snippetChunk.startLine,
       snippet,
       snippetLanguage: chunk.language ?? undefined,

package/src/pipeline/search.ts

@@ -117,6 +117,8 @@ function buildSearchResult(ctx: BuildResultContext): SearchResult {
     score: fts.score, // Raw score, normalized later as batch
     uri: fts.uri ?? "",
     title: fts.title,
+    contentType: fts.contentType,
+    categories: fts.categories,
     line: chunk?.startLine,
     snippet,
     snippetLanguage: chunk?.language ?? undefined,

package/src/pipeline/types.ts

@@ -43,6 +43,8 @@ export interface SearchResult {
   score: number;
   uri: string;
   title?: string;
+  contentType?: string;
+  categories?: string[];
   /** Best source line for editor/agent anchors (1-indexed) */
   line?: number;
   snippet: string;