@gmickel/gno 1.27.1 → 1.28.0

package/src/cli/commands/get.ts

@@ -21,6 +21,10 @@ import {
   getDocumentCapabilities,
   type DocumentCapabilities,
 } from "../../core/document-capabilities";
+import {
+  projectRecordEvidenceMetadata,
+  type RecordEvidenceMetadata,
+} from "../../core/record-metadata";
 import {
   evidenceFromExactDocument,
   RetrievalTraceSession as TraceSession,
@@ -85,6 +89,7 @@ export interface GetResponse {
     converterVersion?: string;
     mirrorHash?: string;
   };
+  record?: RecordEvidenceMetadata;
   capabilities: DocumentCapabilities;
 }
 
@@ -332,6 +337,7 @@ function buildResponse(ctx: BuildResponseContext): GetResult {
       language: doc.languageHint ?? undefined,
       source: buildSourceMeta(doc, config),
       conversion: buildConversionMeta(doc),
+      record: projectRecordEvidenceMetadata(doc),
       capabilities: buildCapabilities(doc),
     },
   };
@@ -349,6 +355,7 @@ interface DocRow {
   sourceSize: number;
   sourceMtime?: string;
   sourceHash: string;
+  recordSourcePath?: string | null;
 }
 
 function buildSourceMeta(
@@ -356,11 +363,12 @@ function buildSourceMeta(
   config: ConfigLike
 ): GetResponse["source"] {
   const coll = config.collections.find((c) => c.name === doc.collection);
-  const absPath = coll ? `${coll.path}/${doc.relPath}` : undefined;
+  const relPath = doc.recordSourcePath ?? doc.relPath;
+  const absPath = coll ? `${coll.path}/${relPath}` : undefined;
 
   return {
     absPath,
-    relPath: doc.relPath,
+    relPath,
     mime: doc.sourceMime,
     ext: doc.sourceExt,
     modifiedAt: doc.sourceMtime ?? undefined,
@@ -373,11 +381,13 @@ function buildCapabilities(doc: {
   sourceExt: string;
   sourceMime: string;
   mirrorHash?: string | null;
+  recordKey?: string | null;
 }): DocumentCapabilities {
   return getDocumentCapabilities({
     sourceExt: doc.sourceExt,
     sourceMime: doc.sourceMime,
     contentAvailable: doc.mirrorHash !== null,
+    recordKey: doc.recordKey,
   });
 }
 

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

@@ -32,6 +32,8 @@ export interface IndexOptions {
   yes?: boolean;
   /** Verbose output */
   verbose?: boolean;
+  /** Emit the complete structured index receipt. */
+  json?: boolean;
 }
 
 /**
@@ -124,6 +126,17 @@ export function formatIndex(
     return `Error: ${result.error}`;
   }
 
+  if (options.json) {
+    return JSON.stringify(
+      {
+        syncResult: result.syncResult,
+        embedSkipped: result.embedSkipped,
+        ...(result.embedResult ? { embedResult: result.embedResult } : {}),
+      },
+      null,
+      2
+    );
+  }
   const { syncResult, embedSkipped } = result;
   const lines: string[] = ["Indexing complete.", ""];
 

package/src/cli/commands/multi-get.ts

@@ -17,6 +17,10 @@ import {
   indexNamesMatch,
   isValidIndexName,
 } from "../../app/index-name";
+import {
+  projectRecordEvidenceMetadata,
+  type RecordEvidenceMetadata,
+} from "../../core/record-metadata";
 import { isGlobPattern, parseRef, splitRefs } from "./ref-parser";
 import { initStore } from "./shared";
 
@@ -53,6 +57,7 @@ export interface MultiGetDocument {
   truncated?: boolean;
   totalLines?: number;
   source: { absPath?: string; relPath: string; mime: string; ext: string };
+  record?: RecordEvidenceMetadata;
 }
 
 export interface SkippedDoc {
@@ -230,6 +235,7 @@ async function fetchSingleDocument(
   );
   const coll = ctx.config.collections.find((c) => c.name === doc.collection);
 
+  const sourceRelPath = doc.recordSourcePath ?? doc.relPath;
   ctx.documents.push({
     docid: doc.docid,
     uri: decorateUriForIndex(doc.uri, ctx.indexName),
@@ -238,11 +244,12 @@ async function fetchSingleDocument(
     truncated: truncated || undefined,
     totalLines: content.split("\n").length,
     source: {
-      absPath: coll ? `${coll.path}/${doc.relPath}` : undefined,
-      relPath: doc.relPath,
+      absPath: coll ? `${coll.path}/${sourceRelPath}` : undefined,
+      relPath: sourceRelPath,
       mime: doc.sourceMime,
       ext: doc.sourceExt,
     },
+    record: projectRecordEvidenceMetadata(doc),
   });
 }
 

package/src/cli/commands/shared.ts

@@ -168,6 +168,34 @@ export function formatSyncResultLines(
       lines.push(`  ${c.filesMarkedInactive} marked inactive`);
     }
 
+    for (const file of c.files ?? []) {
+      const receipt = file.recordImport;
+      if (
+        !receipt ||
+        (receipt.failures.length === 0 && receipt.warnings.length === 0)
+      )
+        continue;
+      const warningCount = receipt.failures.length + receipt.warnings.length;
+      lines.push(
+        `  ${file.relPath}: ${warningCount} record warning${warningCount === 1 ? "" : "s"} (${receipt.snapshotState} snapshot)`
+      );
+      if (options.verbose) {
+        for (const warning of receipt.warnings) {
+          lines.push(
+            `    [${warning.code}]: ${warning.message} (retryable=${warning.retryable ? "yes" : "no"})`
+          );
+        }
+        for (const failure of receipt.failures) {
+          const locator = failure.sourceLocator
+            ? ` at ${failure.sourceLocator}`
+            : "";
+          lines.push(
+            `    [${failure.code}]${locator}: ${failure.message} (retryable=${failure.retryable ? "yes" : "no"})`
+          );
+        }
+      }
+    }
+
     if (options.verbose && c.errors.length > 0) {
       for (const err of c.errors) {
         lines.push(`    [${err.code}] ${err.relPath}: ${err.message}`);

package/src/cli/commands/update.ts

@@ -24,6 +24,8 @@ export interface UpdateOptions {
   gitPull?: boolean;
   /** Verbose output */
   verbose?: boolean;
+  /** Emit the complete structured sync receipt. */
+  json?: boolean;
 }
 
 /**
@@ -80,5 +82,8 @@ export function formatUpdate(
     return `Error: ${result.error}`;
   }
 
+  if (options.json) {
+    return JSON.stringify(result.result, null, 2);
+  }
   return formatSyncResultLines(result.result, options).join("\n");
 }

package/src/cli/program.ts

@@ -1509,6 +1509,7 @@ function wireOnboardingCommands(program: Command): void {
     .option("--no-embed", "skip embedding after sync")
     .option("--git-pull", "run git pull in git repositories")
     .option("--models-pull", "download models if missing")
+    .option("--json", "JSON output")
     .action(
       async (
         collection: string | undefined,
@@ -1525,6 +1526,7 @@ function wireOnboardingCommands(program: Command): void {
           modelsPull: Boolean(cmdOpts.modelsPull),
           yes: globals.yes,
           verbose: globals.verbose,
+          json: getFormat(cmdOpts) === "json",
         };
         const result = await index(opts);
 
@@ -2515,6 +2517,7 @@ function wireManagementCommands(program: Command): void {
     .command("update")
     .description("Sync files from disk into the index")
     .option("--git-pull", "run git pull in git repositories")
+    .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const globals = getGlobals();
       const { update, formatUpdate } = await import("./commands/update");
@@ -2523,6 +2526,7 @@ function wireManagementCommands(program: Command): void {
         indexName: globals.index,
         gitPull: Boolean(cmdOpts.gitPull),
         verbose: globals.verbose,
+        json: getFormat(cmdOpts) === "json",
       };
       const result = await update(opts);
 

package/src/config/project-profile.ts

@@ -5,6 +5,7 @@ import { hasLikelySecretPath } from "../core/path-rules";
 import {
   CONTENT_TYPE_SEARCH_BOOST_MAX,
   CONTENT_TYPE_SEARCH_BOOST_MIN,
+  CollectionSchema,
   isValidLanguageHint,
   PROJECT_AFFINITY_MAX_CONTRIBUTION,
 } from "./types";
@@ -218,6 +219,7 @@ export const ProjectProfileCollectionSchema = z
       .refine(isValidLanguageHint, "Invalid BCP-47 language hint")
       .optional(),
     modelPreset: z.string().regex(REFERENCE_PATTERN).optional(),
+    recordAdapters: CollectionSchema.shape.recordAdapters,
   })
   .strict();
 

package/src/config/types.ts

@@ -10,6 +10,7 @@ import { isAbsolute } from "node:path";
 import { z } from "zod";
 
 import { URI_PREFIX } from "../app/constants";
+import { JsonlFieldMappingSchema } from "../converters/adapters/jsonl/config";
 import { RetrievalTraceConfigSchema } from "./retrieval-traces";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -112,6 +113,21 @@ export const CollectionSchema = z.object({
       gen: z.string().min(1).optional(),
     })
     .optional(),
+
+  /** Optional declarative overrides for ambiguous export formats. */
+  recordAdapters: z
+    .object({
+      jsonl: z
+        .object({ fieldMapping: JsonlFieldMappingSchema.optional() })
+        .strict()
+        .optional(),
+      transcript: z
+        .object({ format: z.enum(["json", "srt", "text", "vtt"]) })
+        .strict()
+        .optional(),
+    })
+    .strict()
+    .optional(),
 });
 
 export type Collection = z.infer<typeof CollectionSchema>;

package/src/converters/adapters/browser-export/adapter.ts

@@ -0,0 +1,199 @@
+import type {
+  RecordAdapter,
+  RecordAdapterEvent,
+  RecordAdapterInput,
+} from "../../types";
+
+import {
+  type BrowserExportRecord,
+  parseBrowserJson,
+  parseNetscapeBookmarks,
+} from "./formats";
+
+const LIVE_PROFILE_MARKERS = [
+  "/library/safari/",
+  "/chrome/user data/",
+  "/google/chrome/",
+  "/chromium/user data/",
+  "/.config/google-chrome/",
+  "/.config/chromium/",
+  "/appdata/local/google/chrome/user data/",
+  "/firefox/profiles/",
+  "/.mozilla/firefox/",
+  "/mozilla/firefox/",
+  "/appdata/roaming/mozilla/firefox/profiles/",
+];
+
+const safeMarkdown = (value: string): string =>
+  value
+    .normalize("NFC")
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replace(/([\\`*_[\]#])/g, "\\$1")
+    .trim();
+
+const liveProfileReason = (input: RecordAdapterInput): string | undefined => {
+  const normalized = input.sourcePath.replaceAll("\\", "/").toLowerCase();
+  if (LIVE_PROFILE_MARKERS.some((marker) => normalized.includes(marker))) {
+    return "live-profile";
+  }
+  const basename = normalized.split("/").at(-1);
+  if (
+    basename === "cookies" ||
+    basename === "history" ||
+    basename?.endsWith(".sqlite") ||
+    basename?.endsWith(".db")
+  ) {
+    return "live-database";
+  }
+  return undefined;
+};
+
+const normalizeUrl = (value: string): string | undefined => {
+  try {
+    const url = new URL(value.trim());
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return undefined;
+    }
+    if (url.username || url.password) return undefined;
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return undefined;
+  }
+};
+
+const readSource = async (input: RecordAdapterInput): Promise<string> => {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let source = "";
+  for await (const chunk of input.open()) {
+    source += decoder.decode(chunk, { stream: true });
+  }
+  return source + decoder.decode();
+};
+
+const recordEvent = (
+  record: BrowserExportRecord
+): RecordAdapterEvent | undefined => {
+  const url = normalizeUrl(record.url);
+  if (!url) return undefined;
+  const title = safeMarkdown(record.title || url);
+  const folder = record.folder ? safeMarkdown(record.folder) : undefined;
+  const tags = record.tags?.map(safeMarkdown).filter(Boolean);
+  const lines = [`# ${title}`, "", url];
+  if (folder) lines.push("", `Folder: ${folder}`);
+  if (tags && tags.length > 0) lines.push(`Tags: ${tags.join(", ")}`);
+  for (const [name, value] of Object.entries(record.dates ?? {}).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    lines.push(`${safeMarkdown(name)}: ${safeMarkdown(value)}`);
+  }
+  const identity = record.externalId
+    ? `${record.kind}:id:${record.externalId}`
+    : `${record.kind}:url:${url}`;
+  return {
+    type: "record",
+    record: {
+      stableId: `browser:${identity}`,
+      sourceLocator: record.sourceLocator,
+      markdown: lines.join("\n"),
+      title,
+      metadata: {
+        categories: ["browser-export", record.kind, ...(tags ?? [])],
+        dateFields: record.dates,
+      },
+      anchors: [{ kind: "record", value: record.sourceLocator }],
+    },
+  };
+};
+
+async function* parseBrowserExport(
+  input: RecordAdapterInput
+): AsyncGenerator<RecordAdapterEvent> {
+  const denied = liveProfileReason(input);
+  if (denied) {
+    yield {
+      type: "failure",
+      failure: {
+        code: "ADAPTER_FAILURE",
+        message: "Live browser profile access is not allowed.",
+        retryable: false,
+        sourceLocator: denied,
+      },
+    };
+    yield { type: "snapshot", state: "partial" };
+    return;
+  }
+
+  let source: string;
+  try {
+    source = await readSource(input);
+  } catch {
+    yield {
+      type: "failure",
+      failure: {
+        code: "MALFORMED_RECORD",
+        message: "Browser export could not be decoded.",
+        retryable: true,
+        sourceLocator: "export",
+      },
+    };
+    yield { type: "snapshot", state: "partial" };
+    return;
+  }
+  const trimmed = source.trimStart();
+  const parsed = trimmed.startsWith("<")
+    ? parseNetscapeBookmarks(
+        source,
+        input.limits.maxRecords,
+        input.limits.maxFailures
+      )
+    : parseBrowserJson(
+        source,
+        input.limits.maxRecords,
+        input.limits.maxFailures
+      );
+  let failures = parsed.failures.length;
+  for (const candidate of parsed.records) {
+    const event = recordEvent(candidate);
+    if (event) yield event;
+    else {
+      failures += 1;
+      yield {
+        type: "failure",
+        failure: {
+          code: "MALFORMED_RECORD",
+          message: "Browser export contained an invalid or unsafe URL.",
+          retryable: false,
+          sourceLocator: candidate.sourceLocator,
+        },
+      };
+    }
+  }
+  for (const locator of parsed.failures) {
+    yield {
+      type: "failure",
+      failure: {
+        code: "MALFORMED_RECORD",
+        message: "Browser export record could not be parsed.",
+        retryable: false,
+        sourceLocator: locator,
+      },
+    };
+  }
+  yield {
+    type: "snapshot",
+    state: failures === 0 ? "complete" : "partial",
+  };
+}
+
+export const browserExportAdapter: RecordAdapter = {
+  id: "adapter/browser-export",
+  version: "1.0.0",
+  canHandle: (mime, ext) =>
+    mime === "application/x-gno-browser-export+json" ||
+    mime === "text/x-gno-browser-bookmarks+html" ||
+    ext === ".browser-export",
+  records: parseBrowserExport,
+};