@gmickel/gno 0.36.0 → 0.37.0

package/src/cli/program.ts

@@ -131,6 +131,41 @@ async function writeOutput(
   }
 }
 
+async function resolveTerminalLinkPolicy(
+  format: "terminal" | "json" | "files" | "csv" | "md" | "xml"
+): Promise<
+  | {
+      isTTY: boolean;
+      editorUriTemplate?: string | null;
+    }
+  | undefined
+> {
+  if (format !== "terminal") {
+    return undefined;
+  }
+
+  const globals = getGlobals();
+  const envTemplate = process.env.GNO_EDITOR_URI_TEMPLATE?.trim();
+  if (envTemplate) {
+    return {
+      isTTY: process.stdout.isTTY ?? false,
+      editorUriTemplate: envTemplate,
+    };
+  }
+
+  const { loadConfig } = await import("../config");
+  const configResult = await loadConfig(globals.config);
+  const configTemplate = configResult.ok
+    ? configResult.value.editorUriTemplate?.trim()
+    : undefined;
+
+  return {
+    isTTY: process.stdout.isTTY ?? false,
+    editorUriTemplate:
+      configTemplate && configTemplate.length > 0 ? configTemplate : null,
+  };
+}
+
 function parseCsvValues(raw: unknown): string[] | undefined {
   if (typeof raw !== "string") {
     return undefined;
@@ -317,6 +352,7 @@ function wireSearchCommands(program: Command): void {
         files: format === "files",
         full: Boolean(cmdOpts.full),
         lineNumbers: Boolean(cmdOpts.lineNumbers),
+        terminalLinks: await resolveTerminalLinkPolicy(format),
       });
       await writeOutput(output, format);
     });
@@ -425,6 +461,7 @@ function wireSearchCommands(program: Command): void {
         files: format === "files",
         full: Boolean(cmdOpts.full),
         lineNumbers: Boolean(cmdOpts.lineNumbers),
+        terminalLinks: await resolveTerminalLinkPolicy(format),
       });
       await writeOutput(output, format);
     });
@@ -594,6 +631,7 @@ function wireSearchCommands(program: Command): void {
         format,
         full: Boolean(cmdOpts.full),
         lineNumbers: Boolean(cmdOpts.lineNumbers),
+        terminalLinks: await resolveTerminalLinkPolicy(format),
       });
       await writeOutput(output, format);
     });

package/src/config/types.ts

@@ -99,9 +99,20 @@ export const CollectionSchema = z.object({
       message: "Invalid BCP-47 language code (e.g., en, de, zh-CN, und)",
     })
     .optional(),
+
+  /** Optional per-collection model overrides */
+  models: z
+    .object({
+      embed: z.string().min(1).optional(),
+      rerank: z.string().min(1).optional(),
+      expand: z.string().min(1).optional(),
+      gen: z.string().min(1).optional(),
+    })
+    .optional(),
 });
 
 export type Collection = z.infer<typeof CollectionSchema>;
+export type CollectionModelOverrides = NonNullable<Collection["models"]>;
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Context Schema
@@ -245,6 +256,9 @@ export const ConfigSchema = z.object({
   /** FTS tokenizer (immutable after init) */
   ftsTokenizer: z.enum(FTS_TOKENIZERS).default(DEFAULT_FTS_TOKENIZER),
 
+  /** Optional terminal hyperlink editor URI template */
+  editorUriTemplate: z.string().min(1).optional(),
+
   /** Collection definitions */
   collections: z.array(CollectionSchema).default([]),
 

package/src/converters/mime.ts

@@ -20,6 +20,15 @@ export interface MimeDetector {
 const EXTENSION_MAP: Record<string, string> = {
   ".md": "text/markdown",
   ".txt": "text/plain",
+  ".ts": "text/plain",
+  ".tsx": "text/plain",
+  ".js": "text/plain",
+  ".jsx": "text/plain",
+  ".py": "text/plain",
+  ".go": "text/plain",
+  ".rs": "text/plain",
+  ".swift": "text/plain",
+  ".c": "text/plain",
   ".pdf": "application/pdf",
   ".docx":
     "application/vnd.openxmlformats-officedocument.wordprocessingml.document",

package/src/ingestion/chunker.ts

@@ -21,6 +21,169 @@ const MAX_OVERLAP_PERCENT = 0.5;
 
 /** Regex for sentence ending followed by whitespace and capital letter (global) */
 const SENTENCE_END_REGEX = /[.!?](\s+)[A-Z]/g;
+const MIN_CODE_CHUNK_PERCENT = 0.35;
+
+type CodeChunkLanguage =
+  | "typescript"
+  | "tsx"
+  | "javascript"
+  | "jsx"
+  | "python"
+  | "go"
+  | "rust";
+
+const CODE_CHUNK_MODE = "automatic";
+
+const CODE_EXTENSION_MAP: Record<string, CodeChunkLanguage> = {
+  ".ts": "typescript",
+  ".tsx": "tsx",
+  ".js": "javascript",
+  ".jsx": "jsx",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+};
+
+const CODE_SUPPORTED_EXTENSIONS = Object.keys(CODE_EXTENSION_MAP);
+
+const CODE_BREAKPOINT_PATTERNS: Record<CodeChunkLanguage, RegExp[]> = {
+  typescript: [
+    /^\s*import\s.+$/gm,
+    /^\s*export\s+(?:default\s+)?(?:class|function|interface|type|enum)\b.*$/gm,
+    /^\s*(?:export\s+)?(?:async\s+)?function\s+\w+/gm,
+    /^\s*(?:export\s+)?class\s+\w+/gm,
+    /^\s*(?:export\s+)?interface\s+\w+/gm,
+    /^\s*(?:export\s+)?type\s+\w+\s*=/gm,
+    /^\s*(?:export\s+)?enum\s+\w+/gm,
+    /^\s*(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/gm,
+  ],
+  tsx: [
+    /^\s*import\s.+$/gm,
+    /^\s*export\s+(?:default\s+)?(?:class|function|interface|type|enum)\b.*$/gm,
+    /^\s*(?:export\s+)?(?:async\s+)?function\s+\w+/gm,
+    /^\s*(?:export\s+)?class\s+\w+/gm,
+    /^\s*(?:export\s+)?interface\s+\w+/gm,
+    /^\s*(?:export\s+)?type\s+\w+\s*=/gm,
+    /^\s*(?:export\s+)?enum\s+\w+/gm,
+    /^\s*(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/gm,
+  ],
+  javascript: [
+    /^\s*import\s.+$/gm,
+    /^\s*export\s+(?:default\s+)?(?:class|function)\b.*$/gm,
+    /^\s*(?:export\s+)?(?:async\s+)?function\s+\w+/gm,
+    /^\s*(?:export\s+)?class\s+\w+/gm,
+    /^\s*(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/gm,
+  ],
+  jsx: [
+    /^\s*import\s.+$/gm,
+    /^\s*export\s+(?:default\s+)?(?:class|function)\b.*$/gm,
+    /^\s*(?:export\s+)?(?:async\s+)?function\s+\w+/gm,
+    /^\s*(?:export\s+)?class\s+\w+/gm,
+    /^\s*(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/gm,
+  ],
+  python: [
+    /^\s*(?:from|import)\s+\w+/gm,
+    /^\s*@[\w.]+/gm,
+    /^\s*(?:async\s+def|def|class)\s+\w+/gm,
+  ],
+  go: [/^\s*import\s+(?:\(|")/gm, /^\s*(?:func|type|const|var)\s+\w+/gm],
+  rust: [
+    /^\s*use\s+[A-Za-z0-9_:{}*, ]+;/gm,
+    /^\s*(?:pub\s+)?(?:fn|struct|enum|trait|impl)\b/gm,
+  ],
+};
+
+export interface CodeChunkingStatus {
+  mode: typeof CODE_CHUNK_MODE;
+  supportedExtensions: string[];
+}
+
+export function getCodeChunkingStatus(): CodeChunkingStatus {
+  return {
+    mode: CODE_CHUNK_MODE,
+    supportedExtensions: [...CODE_SUPPORTED_EXTENSIONS],
+  };
+}
+
+function detectCodeChunkLanguage(
+  sourcePath?: string
+): CodeChunkLanguage | null {
+  if (!sourcePath) {
+    return null;
+  }
+
+  const normalized = sourcePath.toLowerCase();
+  const matchedExtension = Object.keys(CODE_EXTENSION_MAP).find((extension) =>
+    normalized.endsWith(extension)
+  );
+
+  if (!matchedExtension) {
+    return null;
+  }
+
+  return CODE_EXTENSION_MAP[matchedExtension] ?? null;
+}
+
+function collectStructuralBreakPoints(
+  text: string,
+  sourcePath?: string
+): number[] {
+  const language = detectCodeChunkLanguage(sourcePath);
+  if (!language) {
+    return [];
+  }
+
+  const patterns = CODE_BREAKPOINT_PATTERNS[language];
+  if (!patterns) {
+    return [];
+  }
+
+  const points = new Set<number>();
+  for (const pattern of patterns) {
+    pattern.lastIndex = 0;
+    let match: RegExpExecArray | null = null;
+    while (true) {
+      match = pattern.exec(text);
+      if (!match) {
+        break;
+      }
+      if (match.index > 0) {
+        points.add(match.index);
+      }
+    }
+  }
+
+  return [...points].sort((a, b) => a - b);
+}
+
+function findStructuralBreakPoint(
+  breakPoints: number[],
+  currentPos: number,
+  target: number,
+  windowSize: number,
+  minChunkChars: number
+): number | null {
+  if (breakPoints.length === 0) {
+    return null;
+  }
+
+  const minStart = currentPos + minChunkChars;
+  const start = Math.max(minStart, target - windowSize);
+  const end = target + windowSize;
+  const candidates = breakPoints.filter(
+    (point) => point >= start && point <= end
+  );
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  const beforeTarget = candidates.filter((point) => point <= target);
+  if (beforeTarget.length > 0) {
+    return beforeTarget.at(-1) ?? null;
+  }
+
+  return candidates[0] ?? null;
+}
 
 /**
  * Line index for O(1) line number lookups.
@@ -160,7 +323,8 @@ export class MarkdownChunker implements ChunkerPort {
   chunk(
     markdown: string,
     params?: ChunkParams,
-    documentLanguageHint?: string
+    documentLanguageHint?: string,
+    sourcePath?: string
   ): ChunkOutput[] {
     if (!markdown || markdown.trim().length === 0) {
       return [];
@@ -172,9 +336,14 @@ export class MarkdownChunker implements ChunkerPort {
     const maxChars = maxTokens * CHARS_PER_TOKEN;
     const overlapChars = Math.floor(maxChars * overlapPercent);
     const windowSize = Math.floor(maxChars * 0.1); // 10% window for break search
+    const minCodeChunkChars = Math.floor(maxChars * MIN_CODE_CHUNK_PERCENT);
 
     // Build line index once for O(log n) lookups
     const lineIndex = buildLineIndex(markdown);
+    const structuralBreakPoints = collectStructuralBreakPoints(
+      markdown,
+      sourcePath
+    );
 
     const chunks: ChunkOutput[] = [];
     let pos = 0;
@@ -185,12 +354,23 @@ export class MarkdownChunker implements ChunkerPort {
       const targetEnd = pos + maxChars;
 
       let endPos: number;
+      let usedStructuralBreak = false;
       if (targetEnd >= markdown.length) {
         // Last chunk - take rest
         endPos = markdown.length;
       } else {
-        // Find a good break point
-        endPos = findBreakPoint(markdown, targetEnd, windowSize);
+        const structuralBreakPoint = findStructuralBreakPoint(
+          structuralBreakPoints,
+          pos,
+          targetEnd,
+          windowSize,
+          minCodeChunkChars
+        );
+        usedStructuralBreak = structuralBreakPoint !== null;
+        endPos =
+          structuralBreakPoint ??
+          // Find a good prose break point
+          findBreakPoint(markdown, targetEnd, windowSize);
       }
 
       // Extract chunk text - preserve exactly (no trim!)
@@ -224,8 +404,9 @@ export class MarkdownChunker implements ChunkerPort {
         break;
       }
 
-      // Calculate next position with overlap
-      const nextPos = endPos - overlapChars;
+      // Structural chunks should begin on the detected boundary, not in the
+      // middle of the previous code block due to overlap backtracking.
+      const nextPos = usedStructuralBreak ? endPos : endPos - overlapChars;
       pos = Math.max(pos + 1, nextPos); // Ensure we always advance
     }
 

package/src/ingestion/sync.ts

@@ -612,7 +612,8 @@ export class SyncService {
       const chunks = this.chunker.chunk(
         artifact.markdown,
         DEFAULT_CHUNK_PARAMS,
-        artifact.languageHint ?? collection.languageHint
+        artifact.languageHint ?? collection.languageHint,
+        entry.relPath
       );
 
       // 10. Convert to ChunkInput for store

package/src/ingestion/types.ts

@@ -105,7 +105,8 @@ export interface ChunkerPort {
   chunk(
     markdown: string,
     params?: ChunkParams,
-    documentLanguageHint?: string
+    documentLanguageHint?: string,
+    sourcePath?: string
   ): ChunkOutput[];
 }
 

package/src/llm/registry.ts

@@ -5,7 +5,12 @@
  * @module src/llm/registry
  */
 
-import type { Config, ModelConfig, ModelPreset } from "../config/types";
+import type {
+  CollectionModelOverrides,
+  Config,
+  ModelConfig,
+  ModelPreset,
+} from "../config/types";
 import type { ModelType } from "./types";
 
 import { DEFAULT_MODEL_PRESETS } from "../config/types";
@@ -91,6 +96,16 @@ export function getAnswerModelUri(config: Config, override?: string): string {
   return preset.gen;
 }
 
+export function getCollectionModelOverrides(
+  config: Config,
+  collection?: string
+): CollectionModelOverrides | undefined {
+  if (!collection) {
+    return undefined;
+  }
+  return config.collections.find((item) => item.name === collection)?.models;
+}
+
 /**
  * Resolve a model URI for a given type.
  * Uses override if provided, otherwise from active preset.
@@ -98,11 +113,16 @@ export function getAnswerModelUri(config: Config, override?: string): string {
 export function resolveModelUri(
   config: Config,
   type: ModelType,
-  override?: string
+  override?: string,
+  collection?: string
 ): string {
   if (override) {
     return override;
   }
+  const collectionModels = getCollectionModelOverrides(config, collection);
+  if (collectionModels?.[type]) {
+    return collectionModels[type];
+  }
   const preset = getActivePreset(config);
   if (type === "expand") {
     return preset.expand ?? preset.gen;

package/src/mcp/tools/query.ts

@@ -24,7 +24,7 @@ import { resolveDepthPolicy } from "../../core/depth-policy";
 import { normalizeStructuredQueryInput } from "../../core/structured-query";
 import { LlmAdapter } from "../../llm/nodeLlamaCpp/adapter";
 import { resolveDownloadPolicy } from "../../llm/policy";
-import { getActivePreset } from "../../llm/registry";
+import { getActivePreset, resolveModelUri } from "../../llm/registry";
 import { type HybridSearchDeps, searchHybrid } from "../../pipeline/hybrid";
 import {
   createVectorIndexPort,
@@ -171,10 +171,16 @@ export function handleQuery(
       let expandPort: GenerationPort | null = null;
       let rerankPort: RerankPort | null = null;
       let vectorIndex: VectorIndexPort | null = null;
+      const embedUri = resolveModelUri(
+        ctx.config,
+        "embed",
+        undefined,
+        args.collection
+      );
 
       try {
         // Create embedding port (for vector search) - optional
-        const embedResult = await llm.createEmbeddingPort(preset.embed, {
+        const embedResult = await llm.createEmbeddingPort(embedUri, {
           policy,
           onProgress: (progress) => downloadProgress("embed", progress),
         });
@@ -197,7 +203,7 @@ export function handleQuery(
         // Create expansion port - optional
         if (!noExpand && !hasStructuredModes) {
           const genResult = await llm.createExpansionPort(
-            preset.expand ?? preset.gen,
+            resolveModelUri(ctx.config, "expand", undefined, args.collection),
             {
               policy,
               onProgress: (progress) => downloadProgress("expand", progress),
@@ -210,10 +216,13 @@ export function handleQuery(
 
         // Create rerank port - optional
         if (!noRerank) {
-          const rerankResult = await llm.createRerankPort(preset.rerank, {
-            policy,
-            onProgress: (progress) => downloadProgress("rerank", progress),
-          });
+          const rerankResult = await llm.createRerankPort(
+            resolveModelUri(ctx.config, "rerank", undefined, args.collection),
+            {
+              policy,
+              onProgress: (progress) => downloadProgress("rerank", progress),
+            }
+          );
           if (rerankResult.ok) {
             rerankPort = rerankResult.value;
           }
@@ -226,7 +235,7 @@ export function handleQuery(
             const dimensions = embedPort.dimensions();
             const db = ctx.store.getRawDb();
             const vectorResult = await createVectorIndexPort(db, {
-              model: preset.embed,
+              model: embedUri,
               dimensions,
             });
             if (vectorResult.ok) {

package/src/mcp/tools/vsearch.ts

@@ -13,7 +13,7 @@ import { parseUri } from "../../app/constants";
 import { createNonTtyProgressRenderer } from "../../cli/progress";
 import { LlmAdapter } from "../../llm/nodeLlamaCpp/adapter";
 import { resolveDownloadPolicy } from "../../llm/policy";
-import { getActivePreset } from "../../llm/registry";
+import { resolveModelUri } from "../../llm/registry";
 import { formatQueryForEmbedding } from "../../pipeline/contextual";
 import {
   searchVectorWithEmbedding,
@@ -118,8 +118,12 @@ export function handleVsearch(
       }
 
       // Get model from active preset
-      const preset = getActivePreset(ctx.config);
-      const modelUri = preset.embed;
+      const modelUri = resolveModelUri(
+        ctx.config,
+        "embed",
+        undefined,
+        args.collection
+      );
 
       // Resolve download policy from env (MCP has no CLI flags)
       const policy = resolveDownloadPolicy(process.env, {});

package/src/sdk/client.ts

@@ -61,6 +61,7 @@ import { defaultSyncService, type SyncResult } from "../ingestion";
 import { updateFrontmatterTags } from "../ingestion/frontmatter";
 import { LlmAdapter } from "../llm/nodeLlamaCpp/adapter";
 import { resolveDownloadPolicy } from "../llm/policy";
+import { resolveModelUri } from "../llm/registry";
 import {
   generateGroundedAnswer,
   processAnswerResult,
@@ -209,6 +210,7 @@ class GnoClientImpl implements GnoClient {
     expand?: boolean;
     answer?: boolean;
     rerank?: boolean;
+    collection?: string;
     requiredEmbed?: boolean;
     requiredExpand?: boolean;
     requiredAnswer?: boolean;
@@ -228,7 +230,12 @@ class GnoClientImpl implements GnoClient {
 
     if (options.embed) {
       const embedResult = await this.llm.createEmbeddingPort(
-        options.embedModel,
+        resolveModelUri(
+          this.config,
+          "embed",
+          options.embedModel,
+          options.collection
+        ),
         {
           policy: this.downloadPolicy,
         }
@@ -267,7 +274,12 @@ class GnoClientImpl implements GnoClient {
 
     if (options.expand) {
       const genResult = await this.llm.createExpansionPort(
-        options.expandModel ?? options.genModel,
+        resolveModelUri(
+          this.config,
+          "expand",
+          options.expandModel ?? options.genModel,
+          options.collection
+        ),
         {
           policy: this.downloadPolicy,
         }
@@ -285,9 +297,17 @@ class GnoClientImpl implements GnoClient {
     }
 
     if (options.answer) {
-      const genResult = await this.llm.createGenerationPort(options.genModel, {
-        policy: this.downloadPolicy,
-      });
+      const genResult = await this.llm.createGenerationPort(
+        resolveModelUri(
+          this.config,
+          "gen",
+          options.genModel,
+          options.collection
+        ),
+        {
+          policy: this.downloadPolicy,
+        }
+      );
       if (genResult.ok) {
         answerPort = genResult.value;
       } else if (options.requiredAnswer) {
@@ -305,7 +325,12 @@ class GnoClientImpl implements GnoClient {
 
     if (options.rerank) {
       const rerankResult = await this.llm.createRerankPort(
-        options.rerankModel,
+        resolveModelUri(
+          this.config,
+          "rerank",
+          options.rerankModel,
+          options.collection
+        ),
         {
           policy: this.downloadPolicy,
         }
@@ -364,6 +389,7 @@ class GnoClientImpl implements GnoClient {
       embed: true,
       requiredEmbed: true,
       embedModel: options.model,
+      collection: options.collection,
     });
 
     try {
@@ -431,6 +457,7 @@ class GnoClientImpl implements GnoClient {
       expandModel: options.expandModel,
       genModel: options.genModel,
       rerankModel: options.rerankModel,
+      collection: options.collection,
     });
 
     try {
@@ -483,6 +510,7 @@ class GnoClientImpl implements GnoClient {
       genModel: options.genModel,
       embedModel: options.embedModel,
       rerankModel: options.rerankModel,
+      collection: options.collection,
     });
 
     try {

package/src/sdk/embed.ts

@@ -19,7 +19,7 @@ import type {
 import type { GnoEmbedOptions, GnoEmbedResult } from "./types";
 
 import { embedBacklog } from "../embed";
-import { getActivePreset } from "../llm/registry";
+import { resolveModelUri } from "../llm/registry";
 import { formatDocForEmbedding } from "../pipeline/contextual";
 import { err, ok } from "../store/types";
 import {
@@ -191,8 +191,12 @@ export async function runEmbed(
   const batchSize = options.batchSize ?? 32;
   const force = options.force ?? false;
   const dryRun = options.dryRun ?? false;
-  const preset = getActivePreset(runtime.config);
-  const modelUri = options.model ?? preset.embed;
+  const modelUri = resolveModelUri(
+    runtime.config,
+    "embed",
+    options.model,
+    options.collection
+  );
   const db = runtime.store.getRawDb();
   const stats: VectorStatsPort = createVectorStatsPort(db);
 

package/src/sdk/types.ts

@@ -84,6 +84,7 @@ export interface GnoUpdateOptions {
 }
 
 export interface GnoEmbedOptions {
+  collection?: string;
   model?: string;
   batchSize?: number;
   force?: boolean;