@gmickel/gno 1.7.1 → 1.9.0

package/src/cli/program.ts

@@ -247,6 +247,7 @@ export function createProgram(): Command {
   // Wire command groups
   wireSearchCommands(program);
   wireOnboardingCommands(program);
+  wireCaptureCommand(program);
   wireManagementCommands(program);
   wirePublishCommand(program);
   wireVecCommands(program);
@@ -1009,6 +1010,69 @@ function wireOnboardingCommands(program: Command): void {
     });
 }
 
+function wireCaptureCommand(program: Command): void {
+  program
+    .command("capture [content...]")
+    .description("Capture a note with provenance")
+    .option("--stdin", "read capture content from stdin")
+    .option("--file <path>", "read capture content from a text/markdown file")
+    .option("-c, --collection <name>", "target collection")
+    .option("--title <title>", "capture title")
+    .option("--path <relPath>", "explicit relative path inside collection")
+    .option("--folder <relPath>", "folder path inside collection")
+    .option("--preset <id>", "note preset scaffold")
+    .option("--tags <tags>", "comma-separated tags")
+    .option(
+      "--collision-policy <policy>",
+      "error, open_existing, or create_with_suffix"
+    )
+    .option(
+      "--source-kind <kind>",
+      "direct, web, email, meeting, chat, file, api, or unknown"
+    )
+    .option("--source-url <url>", "source URL")
+    .option("--source-title <title>", "source title")
+    .option("--source-author <author>", "source author")
+    .option("--source-date <date>", "source observed date/time")
+    .option("--source-id <id>", "source external id")
+    .option("--json", "JSON output")
+    .action(
+      async (contentParts: string[], cmdOpts: Record<string, unknown>) => {
+        const format = getFormat(cmdOpts);
+        assertFormatSupported(CMD.capture, format);
+        const globals = getGlobals();
+        const { capture, formatCaptureReceipt } =
+          await import("./commands/capture");
+        const receipt = await capture({
+          configPath: globals.config,
+          indexName: globals.index,
+          inlineContent:
+            contentParts.length > 0 ? contentParts.join(" ") : undefined,
+          stdin: Boolean(cmdOpts.stdin),
+          file: cmdOpts.file as string | undefined,
+          collection: cmdOpts.collection as string | undefined,
+          title: cmdOpts.title as string | undefined,
+          path: cmdOpts.path as string | undefined,
+          folder: cmdOpts.folder as string | undefined,
+          preset: cmdOpts.preset as never,
+          tags: cmdOpts.tags as string | undefined,
+          collisionPolicy: cmdOpts.collisionPolicy as never,
+          sourceKind: cmdOpts.sourceKind as never,
+          sourceUrl: cmdOpts.sourceUrl as string | undefined,
+          sourceTitle: cmdOpts.sourceTitle as string | undefined,
+          sourceAuthor: cmdOpts.sourceAuthor as string | undefined,
+          sourceDate: cmdOpts.sourceDate as string | undefined,
+          sourceId: cmdOpts.sourceId as string | undefined,
+        });
+        const output = formatCaptureReceipt(receipt, {
+          json: format === "json",
+          quiet: globals.quiet,
+        });
+        await writeOutput(output, format);
+      }
+    );
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Retrieval Commands (get, multi-get, ls)
 // ─────────────────────────────────────────────────────────────────────────────

package/src/config/content-types.ts

@@ -0,0 +1,140 @@
+/**
+ * Content type config normalization.
+ *
+ * @module src/config/content-types
+ */
+
+import type { NotePresetId } from "../core/note-presets";
+import type { Config, ContentTypeConfig } from "./types";
+
+import { NOTE_PRESETS } from "../core/note-presets";
+
+export type ConfigWarningCode =
+  | "UNKNOWN_CONTENT_TYPE_PRESET"
+  | "DUPLICATE_CONTENT_TYPE_PREFIX";
+
+export interface ConfigWarning {
+  code: ConfigWarningCode;
+  message: string;
+  path: string;
+}
+
+export interface NormalizedContentTypeRule extends ContentTypeConfig {
+  preset: NotePresetId;
+}
+
+export interface ContentTypeNormalizationResult {
+  rules: NormalizedContentTypeRule[];
+  warnings: ConfigWarning[];
+}
+
+export interface ConfigNormalizationResult {
+  config: Config;
+  warnings: ConfigWarning[];
+}
+
+const NOTE_PRESET_IDS = new Set<NotePresetId>(
+  NOTE_PRESETS.map((preset) => preset.id)
+);
+
+function isNotePresetId(value: string): value is NotePresetId {
+  return NOTE_PRESET_IDS.has(value as NotePresetId);
+}
+
+export function normalizeContentTypes(
+  contentTypes: ContentTypeConfig[]
+): ContentTypeNormalizationResult {
+  const warnings: ConfigWarning[] = [];
+  const seenPrefixes = new Set<string>();
+  const rules: NormalizedContentTypeRule[] = [];
+
+  for (const [typeIndex, contentType] of contentTypes.entries()) {
+    const path = `contentTypes[${typeIndex}]`;
+    if (!isNotePresetId(contentType.preset)) {
+      warnings.push({
+        code: "UNKNOWN_CONTENT_TYPE_PRESET",
+        path: `${path}.preset`,
+        message: `Dropped content type "${contentType.id}" because preset "${contentType.preset}" is not a known note preset.`,
+      });
+      continue;
+    }
+
+    const prefixes: string[] = [];
+    for (const [prefixIndex, prefix] of contentType.prefixes.entries()) {
+      if (seenPrefixes.has(prefix)) {
+        warnings.push({
+          code: "DUPLICATE_CONTENT_TYPE_PREFIX",
+          path: `${path}.prefixes[${prefixIndex}]`,
+          message: `Dropped duplicate content type prefix "${prefix}" from "${contentType.id}".`,
+        });
+        continue;
+      }
+
+      seenPrefixes.add(prefix);
+      prefixes.push(prefix);
+    }
+
+    if (prefixes.length === 0) {
+      rules.push({
+        ...contentType,
+        preset: contentType.preset,
+        prefixes,
+      });
+      continue;
+    }
+
+    rules.push({
+      ...contentType,
+      preset: contentType.preset,
+      prefixes: [...prefixes].sort((a, b) => b.length - a.length),
+    });
+  }
+
+  rules.sort((a, b) => {
+    const aLongest = a.prefixes[0]?.length ?? 0;
+    const bLongest = b.prefixes[0]?.length ?? 0;
+    return bLongest - aLongest;
+  });
+
+  return { rules, warnings };
+}
+
+export function normalizeConfigContentTypes(
+  config: Config
+): ConfigNormalizationResult {
+  const normalized = normalizeContentTypes(config.contentTypes ?? []);
+  return {
+    config: {
+      ...config,
+      contentTypes: normalized.rules,
+    },
+    warnings: normalized.warnings,
+  };
+}
+
+export function fingerprintContentTypeRules(
+  rules: NormalizedContentTypeRule[]
+): string {
+  const canonical = rules.map((rule) => ({
+    id: rule.id,
+    preset: rule.preset,
+    prefixes: rule.prefixes,
+  }));
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(JSON.stringify(canonical));
+  return hasher.digest("hex");
+}
+
+export function formatConfigWarning(warning: ConfigWarning): string {
+  return `[config] ${warning.path}: ${warning.message}`;
+}
+
+export function formatConfigWarnings(warnings?: ConfigWarning[]): string[] {
+  return (warnings ?? []).map(formatConfigWarning);
+}
+
+export function writeConfigWarningsToStderr(warnings?: ConfigWarning[]): void {
+  for (const warning of formatConfigWarnings(warnings)) {
+    process.stderr.write(`${warning}\n`);
+  }
+}

package/src/config/defaults.ts

@@ -16,5 +16,6 @@ export function createDefaultConfig(): Config {
     ftsTokenizer: DEFAULT_FTS_TOKENIZER,
     collections: [],
     contexts: [],
+    contentTypes: [],
   };
 }

package/src/config/index.ts

@@ -5,6 +5,16 @@
  */
 
 export { createDefaultConfig } from "./defaults";
+export {
+  type ConfigWarning,
+  fingerprintContentTypeRules,
+  formatConfigWarning,
+  formatConfigWarnings,
+  normalizeConfigContentTypes,
+  normalizeContentTypes,
+  type NormalizedContentTypeRule,
+  writeConfigWarningsToStderr,
+} from "./content-types";
 // Loading
 export {
   isInitialized,
@@ -40,6 +50,10 @@ export {
   CollectionSchema,
   type Config,
   ConfigSchema,
+  CONTENT_TYPE_GRAPH_HINTS,
+  type ContentTypeConfig,
+  type ContentTypeGraphHint,
+  ContentTypeSchema,
   type Context,
   ContextSchema,
   DEFAULT_EXCLUDES,

package/src/config/loader.ts

@@ -7,6 +7,10 @@
 
 import type { ZodError } from "zod";
 
+import {
+  normalizeConfigContentTypes,
+  type ConfigWarning,
+} from "./content-types";
 import { configExists, expandPath, getConfigPaths } from "./paths";
 import { CONFIG_VERSION, type Config, ConfigSchema } from "./types";
 
@@ -15,7 +19,7 @@ import { CONFIG_VERSION, type Config, ConfigSchema } from "./types";
 // ─────────────────────────────────────────────────────────────────────────────
 
 export type LoadResult<T> =
-  | { ok: true; value: T }
+  | { ok: true; value: T; warnings: ConfigWarning[] }
   | { ok: false; error: LoadError };
 
 export type LoadError =
@@ -128,7 +132,12 @@ export async function loadConfigFromPath(
     };
   }
 
-  return { ok: true, value: result.data };
+  const normalized = normalizeConfigContentTypes(result.data);
+  return {
+    ok: true,
+    value: normalized.config,
+    warnings: normalized.warnings,
+  };
 }
 
 /**

package/src/config/types.ts

@@ -245,6 +245,37 @@ export const ModelConfigSchema = z.object({
 
 export type ModelConfig = z.infer<typeof ModelConfigSchema>;
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Content Type Schema
+// ─────────────────────────────────────────────────────────────────────────────
+
+export const CONTENT_TYPE_GRAPH_HINTS = [
+  "mentions",
+  "works_at",
+  "attended",
+  "decided",
+  "related_to",
+] as const;
+
+export type ContentTypeGraphHint = (typeof CONTENT_TYPE_GRAPH_HINTS)[number];
+
+export const ContentTypeSchema = z.object({
+  /** Stable content type identifier */
+  id: z.string().min(1),
+  /** Relative path prefixes that map to this content type */
+  prefixes: z.array(z.string().min(1)),
+  /** Note preset ID, resolved post-parse so unknown refs warn-and-drop */
+  preset: z.string().min(1),
+  /** Reserved for fn-84 typed graph hints; accepted but no-op in fn-83 */
+  graphHints: z.array(z.string().min(1)).optional(),
+  /** Reserved for future ranking; accepted but no-op in fn-83 */
+  searchBoost: z.number().finite().optional(),
+  /** Marks time-oriented content types; accepted but no-op in fn-83 */
+  temporal: z.boolean().optional(),
+});
+
+export type ContentTypeConfig = z.infer<typeof ContentTypeSchema>;
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Config Schema (root)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -265,11 +296,16 @@ export const ConfigSchema = z.object({
   /** Context metadata */
   contexts: z.array(ContextSchema).default([]),
 
+  /** Opt-in schema-lite content type rules */
+  contentTypes: z.array(ContentTypeSchema).default([]),
+
   /** Model configuration */
   models: ModelConfigSchema.optional(),
 });
 
-export type Config = z.infer<typeof ConfigSchema>;
+export type Config = Omit<z.infer<typeof ConfigSchema>, "contentTypes"> & {
+  contentTypes?: ContentTypeConfig[];
+};
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Scope Utilities

package/src/core/capture-write.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared capture write semantics.
+ *
+ * @module src/core/capture-write
+ */
+
+import type { CapturePlan } from "./capture";
+
+import { atomicCreate, atomicWrite } from "./file-ops";
+
+function isFileExistsError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    typeof error.code === "string" &&
+    error.code === "EEXIST"
+  );
+}
+
+export async function writeCapturePlanFile(
+  plan: CapturePlan,
+  absPath: string
+): Promise<void> {
+  try {
+    if (plan.overwrite) {
+      await atomicWrite(absPath, plan.content);
+      return;
+    }
+    await atomicCreate(absPath, plan.content);
+  } catch (error) {
+    if (isFileExistsError(error)) {
+      throw new Error(
+        "File already exists. Use open_existing, create_with_suffix, or overwrite."
+      );
+    }
+    throw error;
+  }
+}