@gmickel/gno 1.7.1 → 1.9.0

package/README.md

@@ -92,9 +92,16 @@ gno daemon --detach  # headless continuous indexing (background; --status / --st
 
 ## What's New
 
-> Latest release: [v1.1.0](./CHANGELOG.md#110---2026-04-21)  
+> Latest release: [v1.8.0](./CHANGELOG.md#180---2026-06-05)  
 > Full release history: [CHANGELOG.md](./CHANGELOG.md)
 
+- **Second-brain capture**: `gno capture`, REST `/api/capture`, SDK
+  `client.capture()`, MCP `gno_capture`, and Web UI Quick Capture write
+  provenance-rich notes from text, stdin, or files, including typed presets for
+  ideas, people, company/projects, and meetings
+- **Schema-lite content types**: optional `contentTypes` rules map configured
+  frontmatter `type` values or path prefixes to canonical `contentType` metadata
+  in JSON search/query results
 - **Publish to [gno.sh](https://gno.sh/publish)**: new `gno publish export` CLI and Web UI action produce a self-contained artifact you upload to the hosted reader — public, secret, invite-only, or locally encrypted before upload
 - **Retrieval Quality Upgrade**: stronger BM25 lexical handling, code-aware chunking, terminal result hyperlinks, and per-collection model overrides
 - **Code Embedding Benchmarks**: new benchmark workflow across canonical, real-GNO, and pinned OSS slices for comparing alternate embedding models
@@ -543,6 +550,8 @@ Open `http://localhost:3000` to:
 - **Browse**: Cross-collection tree workspace with folder detail panes and per-tab browse context
 - **Edit**: Create, edit, and delete documents with live preview
 - **Create in place**: New notes in the current folder/collection with presets and command-palette flows
+- **Capture with provenance**: `gno capture` and Web UI Quick Capture write quick notes to an editable collection with structured `source:` metadata, typed preset scaffolds, and a receipt that separates write, sync, and embed state
+- **Same capture contract everywhere**: CLI, MCP `gno_capture`, REST `/api/capture`, SDK `client.capture()`, and Web UI Quick Capture return the same provenance receipt shape
 - **Ask**: AI-powered Q&A with citations
 - **Manage Collections**: Add, remove, and re-index collections
 - **Connect agents**: Install core Skill/MCP integrations from the app

package/assets/skill/SKILL.md

@@ -207,6 +207,47 @@ gno embed --collection travel
 
 MCP `gno.sync` and `gno.capture` do NOT auto-embed. Use CLI for embedding.
 
+## Capture Notes
+
+Use `gno capture` for quick second-brain writes into an editable collection:
+
+```bash
+gno capture "thought to remember"
+gno capture --file ./clip.md --source-url https://example.com --source-kind web --json
+gno capture --preset person --title "Jane Doe" --folder people/
+gno capture --preset meeting --title "Weekly sync" --folder meetings/
+```
+
+Preset IDs: `blank`, `project-note`, `research-note`, `decision-note`,
+`prompt-pattern`, `source-summary`, `idea-original`, `person`,
+`company-project`, `meeting`.
+
+For second-brain pages, prefer the typed presets:
+
+- `idea-original`: exact idea phrasing, context, related concepts, publish potential.
+- `person`: current state, relationship, assessment, open threads, timeline.
+- `company-project`: state, changes, decisions, people, timeline.
+- `meeting`: synthesis/action analysis above `## Timeline`; raw notes below.
+
+The JSON receipt reports write, sync, and embed status separately. Generated
+captures land under `inbox/YYYY-MM-DD/capture-<body-hash>.md` unless `--path`,
+`--folder`, or `--title` overrides the path. Capture does not imply embedding
+unless `embed.status` is `completed`. Capture inputs must be text; binary-like
+file/stdin content is rejected before writing. CLI, REST, SDK, and Web capture
+writes fail instead of replacing late-arriving files; legacy `overwrite` is
+MCP-only.
+
+Programmatic capture uses the same receipt contract:
+
+- MCP: `gno_capture` (requires `gno mcp --enable-write`)
+- REST: `POST /api/capture`
+- SDK: `client.capture({ collection, content, source, tags })`
+
+MCP capture writes structured `source:` frontmatter, runs under the MCP write
+lock, syncs the file for FTS, and preserves legacy MCP fields (`docid`,
+`absPath`, `overwritten`, `serverInstanceId`) alongside the shared receipt. It
+does not auto-embed.
+
 ## Collection-specific embedding models
 
 Collections can override the global embedding model with `models.embed`.

package/assets/skill/cli-reference.md

@@ -111,6 +111,40 @@ Generate embeddings only.
 gno embed [--force] [--model <uri>] [--batch-size <n>] [--dry-run]
 ```
 
+## Capture
+
+### gno capture
+
+Capture a note into an editable collection with provenance.
+
+```bash
+gno capture "thought to remember"
+gno capture --stdin --collection notes --preset source-summary --tags inbox,gno
+gno capture --file ./clip.md --source-url https://example.com --source-kind web --json
+gno capture "meeting note" --quiet
+```
+
+Preset IDs: `blank`, `project-note`, `research-note`, `decision-note`,
+`prompt-pattern`, `source-summary`, `idea-original`, `person`,
+`company-project`, `meeting`.
+
+Second-brain presets keep current synthesis above `## Timeline` and dated
+evidence below it. Use `idea-original` for exact idea wording, `person` for
+relationship/current-state notes, `company-project` for organizations or active
+workstreams, and `meeting` for analysis above transcript/raw notes/action items.
+
+Important behavior:
+
+- Inline content, `--stdin`, and `--file` are mutually exclusive.
+- Capture accepts text only; binary-like file/stdin content is rejected before
+  writing.
+- Without `--path`, `--folder`, or `--title`, captures use
+  `inbox/YYYY-MM-DD/capture-<body-hash>.md` in UTC.
+- Capture writes fail instead of replacing a late-arriving file.
+- `--json` returns a capture receipt with separate write, sync, and embed status.
+- Capture syncs the file into FTS but does not imply embedding unless
+  `embed.status` is `completed`.
+
 ## Search Commands
 
 ### gno search

package/assets/skill/examples.md

@@ -349,3 +349,40 @@ gno search "common term" --min-score 0.7
 # Get full content
 gno search "term" --full
 ```
+
+## Capture Notes
+
+### CLI capture with provenance
+
+```bash
+gno capture "thought to remember"
+gno capture --file ./clip.md --source-url https://example.com --source-kind web --json
+```
+
+### Typed second-brain presets
+
+```bash
+# Original idea: preserve exact phrasing and related concepts
+gno capture --preset idea-original --title "Local-first inbox triage" --folder ideas/
+
+# Person page: current synthesis plus relationship/open threads/timeline
+gno capture --preset person --title "Jane Doe" --folder people/
+
+# Company/project page: state, decisions, people, and timeline
+gno capture --preset company-project --title "Acme renewal" --folder projects/
+
+# Meeting page: analysis above raw notes, transcript, and action items
+gno capture --preset meeting --title "Weekly sync" --folder meetings/
+```
+
+For these presets, keep current synthesis above `## Timeline`; put dated evidence
+and raw chronology below it. If `contentTypes` are configured in `index.yml`,
+matching frontmatter `type` or path prefixes become `contentType` in JSON search
+results.
+
+### Web UI quick capture
+
+Press **N** in `gno serve`, write the note, and open **Source** only when you
+need provenance fields such as URL, author, observed date, or external id. The
+success view reports the write result, FTS sync state, and embed state
+separately.

package/assets/skill/mcp-reference.md

@@ -68,6 +68,27 @@ community summaries,
 Graph edges include confidence/audit metadata; prefer `explicit` edges when
 answers depend on link certainty.
 
+## Capture
+
+`gno_capture` is available only when MCP starts with `--enable-write` or
+`GNO_MCP_ENABLE_WRITE=1`. It writes quick notes with structured `source:`
+frontmatter and returns the same provenance receipt shape as CLI, REST, and SDK
+capture, plus legacy MCP fields (`docid`, `absPath`, `overwritten`,
+`serverInstanceId`).
+
+`presetId` accepts `blank`, `project-note`, `research-note`, `decision-note`,
+`prompt-pattern`, `source-summary`, `idea-original`, `person`,
+`company-project`, or `meeting`. The typed second-brain presets use flat
+frontmatter (`type`, `category`, `tags`) and a synthesis/timeline page pattern;
+provenance still comes from the capture `source` fields, not the preset.
+
+Use `collisionPolicy: "open_existing"` to return an existing note without
+rewriting, `create_with_suffix` to create the next available path, or legacy
+`overwrite: true` to replace the target path. Capture content must be text, and
+non-overwrite captures fail instead of replacing a late-arriving file. MCP
+capture syncs the file for FTS but does not auto-embed; run `gno_embed` or
+`gno_index` afterward when vector search should include it.
+
 ## Uninstall
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/cli/commands/capture.ts

@@ -0,0 +1,282 @@
+/**
+ * gno capture command implementation.
+ *
+ * @module src/cli/commands/capture
+ */
+
+// node:fs/promises for mkdir (no Bun equivalent for recursive dir creation)
+import { mkdir } from "node:fs/promises";
+// node:path has no Bun path utilities
+import { dirname, join } from "node:path";
+
+import type {
+  CapturePlan,
+  CaptureReceipt,
+  CaptureSourceKind,
+} from "../../core/capture";
+import type { NoteCollisionPolicy } from "../../core/note-creation";
+import type { NotePresetId } from "../../core/note-presets";
+
+import { getIndexDbPath } from "../../app/constants";
+import {
+  buildCaptureReceipt,
+  listCaptureDiskRelPaths,
+  planCapture,
+  serializeCaptureReceipt,
+} from "../../core/capture";
+import { writeCapturePlanFile } from "../../core/capture-write";
+import { withWriteLock } from "../../core/file-lock";
+import { defaultSyncService, withContentTypeRules } from "../../ingestion";
+import { CliError } from "../errors";
+import { initStore } from "./shared";
+
+export interface CaptureCliOptions {
+  configPath?: string;
+  indexName?: string;
+  inlineContent?: string;
+  stdin?: boolean;
+  file?: string;
+  collection?: string;
+  title?: string;
+  path?: string;
+  folder?: string;
+  preset?: NotePresetId;
+  tags?: string;
+  collisionPolicy?: NoteCollisionPolicy;
+  sourceKind?: CaptureSourceKind;
+  sourceUrl?: string;
+  sourceTitle?: string;
+  sourceAuthor?: string;
+  sourceDate?: string;
+  sourceId?: string;
+}
+
+const SOURCE_KINDS = new Set<CaptureSourceKind>([
+  "direct",
+  "web",
+  "email",
+  "meeting",
+  "chat",
+  "file",
+  "api",
+  "unknown",
+]);
+const COLLISION_POLICIES = new Set<NoteCollisionPolicy>([
+  "error",
+  "open_existing",
+  "create_with_suffix",
+]);
+
+function parseTags(raw: string | undefined): string[] {
+  return (
+    raw
+      ?.split(",")
+      .map((tag) => tag.trim())
+      .filter((tag) => tag.length > 0) ?? []
+  );
+}
+
+async function readContent(
+  options: CaptureCliOptions
+): Promise<string | undefined> {
+  const sources = [
+    options.inlineContent?.trim().length ? "inline" : null,
+    options.stdin ? "stdin" : null,
+    options.file ? "file" : null,
+  ].filter((source) => source !== null);
+  if (sources.length > 1) {
+    throw new CliError(
+      "VALIDATION",
+      "Use only one content source: inline, --stdin, or --file."
+    );
+  }
+
+  if (options.stdin) {
+    return await Bun.stdin.text();
+  }
+  if (options.file) {
+    return await Bun.file(options.file).text();
+  }
+  return options.inlineContent;
+}
+
+function buildSource(options: CaptureCliOptions) {
+  if (options.sourceKind && !SOURCE_KINDS.has(options.sourceKind)) {
+    throw new CliError(
+      "VALIDATION",
+      "--source-kind must be one of: direct, web, email, meeting, chat, file, api, unknown"
+    );
+  }
+  return {
+    kind: options.sourceKind,
+    url: options.sourceUrl,
+    title: options.sourceTitle,
+    author: options.sourceAuthor,
+    observedAt: options.sourceDate,
+    externalId: options.sourceId,
+  };
+}
+
+function validateCollisionPolicy(
+  policy: NoteCollisionPolicy | undefined
+): void {
+  if (policy && !COLLISION_POLICIES.has(policy)) {
+    throw new CliError(
+      "VALIDATION",
+      "--collision-policy must be one of: error, open_existing, create_with_suffix"
+    );
+  }
+}
+
+export async function capture(
+  options: CaptureCliOptions
+): Promise<CaptureReceipt> {
+  const storeInit = await initStore({
+    configPath: options.configPath,
+    indexName: options.indexName,
+    syncConfig: true,
+  });
+  if (!storeInit.ok) {
+    throw new CliError("VALIDATION", storeInit.error);
+  }
+
+  const { store, collections, config } = storeInit;
+  try {
+    const collectionName = options.collection?.trim();
+    const collection = collectionName
+      ? collections.find(
+          (candidate) =>
+            candidate.name.toLowerCase() === collectionName.toLowerCase()
+        )
+      : collections[0];
+    if (!collection) {
+      throw new CliError(
+        "VALIDATION",
+        collectionName
+          ? `Collection not found: ${collectionName}`
+          : "No editable collection configured."
+      );
+    }
+
+    validateCollisionPolicy(options.collisionPolicy);
+    const content = await readContent(options);
+    const existingDocs = await store.listDocuments(collection.name);
+    if (!existingDocs.ok) {
+      throw new Error(existingDocs.error.message);
+    }
+    const diskRelPaths = await listCaptureDiskRelPaths(collection.path);
+    let plan: CapturePlan;
+    try {
+      plan = planCapture({
+        input: {
+          collection: collection.name,
+          content,
+          title: options.title,
+          relPath: options.path,
+          folderPath: options.folder,
+          collisionPolicy: options.collisionPolicy,
+          presetId: options.preset,
+          tags: parseTags(options.tags),
+          source: buildSource(options),
+        },
+        existingRelPaths: existingDocs.value.map((doc) => doc.relPath),
+        diskRelPaths,
+      });
+    } catch (error) {
+      throw new CliError(
+        "VALIDATION",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    const absPath = join(collection.path, plan.relPath);
+
+    const lockPath = join(
+      dirname(getIndexDbPath(options.indexName)),
+      ".mcp-write.lock"
+    );
+    return await withWriteLock(lockPath, async () => {
+      if (plan.openedExisting) {
+        const existingDoc = await store.getDocument(
+          collection.name,
+          plan.relPath
+        );
+        if (!existingDoc.ok) {
+          throw new Error(existingDoc.error.message);
+        }
+        return buildCaptureReceipt({
+          plan,
+          absPath,
+          docid: existingDoc.value?.docid,
+          sync: existingDoc.value
+            ? { status: "completed" }
+            : {
+                status: "skipped",
+                reason: "Existing file is not indexed yet.",
+              },
+        });
+      }
+
+      await mkdir(dirname(absPath), { recursive: true });
+      await writeCapturePlanFile(plan, absPath);
+      const syncResults = await defaultSyncService.syncFiles(
+        collection,
+        store,
+        [plan.relPath],
+        withContentTypeRules(
+          {
+            runUpdateCmd: false,
+            gitPull: false,
+          },
+          config
+        )
+      );
+      const syncResult = syncResults[0];
+      const docResult = await store.getDocument(collection.name, plan.relPath);
+      const docid = docResult.ok ? docResult.value?.docid : undefined;
+      return buildCaptureReceipt({
+        plan,
+        absPath,
+        docid: syncResult?.docid ?? docid,
+        sync:
+          syncResult?.status === "error"
+            ? {
+                status: "failed",
+                error:
+                  syncResult.errorMessage ??
+                  syncResult.errorCode ??
+                  "Unknown sync error",
+              }
+            : { status: "completed" },
+      });
+    });
+  } finally {
+    await store.close();
+  }
+}
+
+export function formatCaptureReceipt(
+  receipt: CaptureReceipt,
+  options: { json?: boolean; quiet?: boolean } = {}
+): string {
+  if (options.json) {
+    return serializeCaptureReceipt(receipt);
+  }
+  if (options.quiet) {
+    return receipt.uri;
+  }
+
+  const lines = [
+    receipt.openedExisting ? "Opened existing capture." : "Captured note.",
+    `URI: ${receipt.uri}`,
+    `Path: ${receipt.absPath ?? receipt.relPath}`,
+    `Sync: ${receipt.sync.status}`,
+    `Embed: ${receipt.embed.status}`,
+  ];
+  if (receipt.tags.length > 0) {
+    lines.push(`Tags: ${receipt.tags.join(", ")}`);
+  }
+  if (receipt.source.url) {
+    lines.push(`Source: ${receipt.source.url}`);
+  }
+  return lines.join("\n");
+}

package/src/cli/commands/index-cmd.ts

@@ -5,7 +5,11 @@
  * @module src/cli/commands/indexCmd
  */
 
-import { defaultSyncService, type SyncResult } from "../../ingestion";
+import {
+  defaultSyncService,
+  type SyncResult,
+  withContentTypeRules,
+} from "../../ingestion";
 import { formatSyncResultLines, initStore } from "./shared";
 
 /**
@@ -55,14 +59,21 @@ export async function index(options: IndexOptions = {}): Promise<IndexResult> {
     return { success: false, error: initResult.error };
   }
 
-  const { store, collections } = initResult;
+  const { store, collections, config } = initResult;
 
   try {
     // Run sync service (update phase)
-    const syncResult = await defaultSyncService.syncAll(collections, store, {
-      gitPull: options.gitPull,
-      runUpdateCmd: true,
-    });
+    const syncResult = await defaultSyncService.syncAll(
+      collections,
+      store,
+      withContentTypeRules(
+        {
+          gitPull: options.gitPull,
+          runUpdateCmd: true,
+        },
+        config
+      )
+    );
 
     // Embedding phase
     const embedSkipped = options.noEmbed ?? false;

package/src/cli/commands/shared.ts

@@ -10,7 +10,12 @@ import type { SyncResult } from "../../ingestion";
 import type { SearchResults } from "../../pipeline/types";
 
 import { decorateUriForIndex, getIndexDbPath } from "../../app/constants";
-import { getConfigPaths, isInitialized, loadConfig } from "../../config";
+import {
+  getConfigPaths,
+  isInitialized,
+  loadConfig,
+  writeConfigWarningsToStderr,
+} from "../../config";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
 
 /**
@@ -61,6 +66,7 @@ export async function initStore(
   if (!configResult.ok) {
     return { ok: false, error: configResult.error.message };
   }
+  writeConfigWarningsToStderr(configResult.warnings);
   const config = configResult.value;
 
   // Filter to single collection if specified
@@ -165,6 +171,16 @@ export function formatSyncResultLines(
         lines.push(`    [${err.code}] ${err.relPath}: ${err.message}`);
       }
     }
+    if (options.verbose && c.files?.length) {
+      for (const file of c.files) {
+        if (!file.contentType || !file.contentTypeSource) {
+          continue;
+        }
+        lines.push(
+          `    [${file.status}] ${file.relPath}: contentType=${file.contentType} (${file.contentTypeSource})`
+        );
+      }
+    }
   }
 
   lines.push("");

package/src/cli/commands/update.ts

@@ -5,7 +5,11 @@
  * @module src/cli/commands/update
  */
 
-import { defaultSyncService, type SyncResult } from "../../ingestion";
+import {
+  defaultSyncService,
+  type SyncResult,
+  withContentTypeRules,
+} from "../../ingestion";
 import { formatSyncResultLines, initStore } from "./shared";
 
 /**
@@ -43,14 +47,21 @@ export async function update(
     return { success: false, error: initResult.error };
   }
 
-  const { store, collections } = initResult;
+  const { store, collections, config } = initResult;
 
   try {
     // Run sync service
-    const result = await defaultSyncService.syncAll(collections, store, {
-      gitPull: options.gitPull,
-      runUpdateCmd: true,
-    });
+    const result = await defaultSyncService.syncAll(
+      collections,
+      store,
+      withContentTypeRules(
+        {
+          gitPull: options.gitPull,
+          runUpdateCmd: true,
+        },
+        config
+      )
+    );
 
     return { success: true, result };
   } finally {

package/src/cli/options.ts

@@ -38,6 +38,7 @@ export const CMD = {
   backlinks: "backlinks",
   similar: "similar",
   graph: "graph",
+  capture: "capture",
 } as const;
 
 export type CommandId = (typeof CMD)[keyof typeof CMD];
@@ -63,6 +64,7 @@ const FORMAT_SUPPORT: Record<CommandId, OutputFormat[]> = {
   [CMD.similar]: ["terminal", "json", "md"],
   // graph uses custom --dot/--mermaid flags (not OutputFormat) and writes via terminal output
   [CMD.graph]: ["json", "terminal"],
+  [CMD.capture]: ["terminal", "json"],
 };
 
 // ─────────────────────────────────────────────────────────────────────────────