@gmickel/gno 1.25.1 → 1.27.0

package/src/cli/commands/status.ts

@@ -5,11 +5,17 @@
  * @module src/cli/commands/status
  */
 
+import type { ContentTypeBoostStatus } from "../../config/content-types";
 import type { ActivationStatus } from "../../core/activation-status";
 import type { IndexStatus } from "../../store/types";
 
 import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
-import { getConfigPaths, isInitialized, loadConfig } from "../../config";
+import {
+  buildContentTypeBoostStatus,
+  getConfigPaths,
+  isInitialized,
+  loadConfig,
+} from "../../config";
 import { isConnectorActivationComplete } from "../../core/activation-connector-health";
 import { buildActivationStatus } from "../../core/activation-status";
 import { ModelCache } from "../../llm/cache";
@@ -36,7 +42,12 @@ export interface StatusOptions {
  * Result of status command.
  */
 export type StatusResult =
-  | { success: true; status: IndexStatus; activation: ActivationStatus }
+  | {
+      success: true;
+      status: IndexStatus;
+      activation: ActivationStatus;
+      contentTypeBoost: ContentTypeBoostStatus;
+    }
   | { success: false; error: string };
 
 function connectorProjectionLine(activation: ActivationStatus): string | null {
@@ -63,7 +74,8 @@ function isStatusHealthy(
  */
 function formatTerminal(
   indexStatus: IndexStatus,
-  activation: ActivationStatus
+  activation: ActivationStatus,
+  contentTypeBoost: ContentTypeBoostStatus
 ): string {
   const lines: string[] = [];
 
@@ -101,6 +113,11 @@ function formatTerminal(
     lines.push(`Last updated: ${indexStatus.lastUpdatedAt}`);
   }
 
+  lines.push(
+    `Content-type boosts: ${contentTypeBoost.rules.length ? contentTypeBoost.rules.map((rule) => `${rule.id}=${rule.searchBoost}`).join(", ") : "none"}`
+  );
+  lines.push(`Ranking fingerprint: ${contentTypeBoost.rulesFingerprint}`);
+
   lines.push(
     `Health: ${isStatusHealthy(indexStatus, activation) ? "OK" : "DEGRADED"}`
   );
@@ -138,7 +155,8 @@ function formatTerminal(
  */
 function formatMarkdown(
   indexStatus: IndexStatus,
-  activation: ActivationStatus
+  activation: ActivationStatus,
+  contentTypeBoost: ContentTypeBoostStatus
 ): string {
   const lines: string[] = [];
 
@@ -174,6 +192,10 @@ function formatMarkdown(
   if (indexStatus.lastUpdatedAt) {
     lines.push(`- **Last updated**: ${indexStatus.lastUpdatedAt}`);
   }
+  lines.push(
+    `- **Content-type boosts**: ${contentTypeBoost.rules.length ? contentTypeBoost.rules.map((rule) => `${rule.id}=${rule.searchBoost}`).join(", ") : "none"}`
+  );
+  lines.push(`- **Ranking fingerprint**: ${contentTypeBoost.rulesFingerprint}`);
 
   lines.push("");
   lines.push("## Lexical activation");
@@ -254,7 +276,12 @@ export async function status(
       }
     );
 
-    return { success: true, status: statusResult.value, activation };
+    return {
+      success: true,
+      status: statusResult.value,
+      activation,
+      contentTypeBoost: buildContentTypeBoostStatus(config.contentTypes ?? []),
+    };
   } finally {
     await store.close();
   }
@@ -294,6 +321,7 @@ export function formatStatus(
         embeddingBacklog: s.embeddingBacklog,
         lastUpdated: s.lastUpdatedAt,
         healthy: isStatusHealthy(s, result.activation),
+        contentTypeBoost: result.contentTypeBoost,
         activation: result.activation,
       },
       null,
@@ -302,8 +330,16 @@ export function formatStatus(
   }
 
   if (options.md) {
-    return formatMarkdown(result.status, result.activation);
+    return formatMarkdown(
+      result.status,
+      result.activation,
+      result.contentTypeBoost
+    );
   }
 
-  return formatTerminal(result.status, result.activation);
+  return formatTerminal(
+    result.status,
+    result.activation,
+    result.contentTypeBoost
+  );
 }

package/src/cli/program.ts

@@ -1151,6 +1151,7 @@ function wireSearchCommands(program: Command): void {
     .option("--context-budget-bytes <num>", "verified Context byte budget")
     .option("--min-score <score>", "minimum retrieval score (0-1)")
     .option("--graph", "include bounded graph expansion")
+    .option("--explain", "include retrieval scoring explanation")
     .option(
       "--project-root <path>",
       "trusted project root (repeatable; replaces cwd affinity)",
@@ -1259,6 +1260,7 @@ function wireSearchCommands(program: Command): void {
         noExpand: depthPolicy.noExpand,
         noRerank: depthPolicy.noRerank,
         candidateLimit: depthPolicy.candidateLimit,
+        explain: Boolean(cmdOpts.explain),
         // Per spec: --answer defaults to false, --no-answer forces retrieval-only
         // Commander creates separate cmdOpts.noAnswer for --no-answer flag
         answer: Boolean(cmdOpts.answer),
@@ -1291,6 +1293,77 @@ function wireSearchCommands(program: Command): void {
 // ─────────────────────────────────────────────────────────────────────────────
 
 function wireOnboardingCommands(program: Command): void {
+  const profileCmd = program
+    .command("profile")
+    .description("Inspect a project-local retrieval profile");
+
+  const wireProfileRead = (
+    command: "check" | "show" | "diff",
+    description: string
+  ): void => {
+    profileCmd
+      .command(`${command} [path]`)
+      .description(description)
+      .option("--json", "JSON output")
+      .action(
+        async (path: string | undefined, cmdOpts: Record<string, unknown>) => {
+          const globals = getGlobals();
+          const json = Boolean(cmdOpts.json) || globals.json;
+          const { formatProjectProfileResult, runProjectProfileCommand } =
+            await import("./commands/profile");
+          const outcome = await runProjectProfileCommand({
+            command,
+            path,
+            configPath: globals.config,
+            offline: globals.offline,
+          });
+          process.stdout.write(
+            `${formatProjectProfileResult(outcome.result, { json })}\n`
+          );
+          if (outcome.exitCode !== 0) {
+            throw new CliError(
+              outcome.exitCode === 1 ? "VALIDATION" : "RUNTIME",
+              "Project profile inspection failed",
+              { silent: true }
+            );
+          }
+        }
+      );
+  };
+
+  wireProfileRead("check", "Validate a project-local retrieval profile");
+  wireProfileRead("show", "Show normalized project-local retrieval state");
+  wireProfileRead("diff", "Compare a project profile with local config");
+  profileCmd
+    .command("apply [path]")
+    .description("Apply a project profile without implicit deletion")
+    .option("--json", "JSON output")
+    .action(
+      async (path: string | undefined, cmdOpts: Record<string, unknown>) => {
+        const globals = getGlobals();
+        const json = Boolean(cmdOpts.json) || globals.json;
+        const {
+          formatProjectProfileApplyResult,
+          runProjectProfileApplyCommand,
+        } = await import("./commands/profile-apply");
+        const outcome = await runProjectProfileApplyCommand({
+          path,
+          configPath: globals.config,
+          indexName: globals.index,
+        });
+        process.stdout.write(
+          `${formatProjectProfileApplyResult(outcome.result, { json })}\n`
+        );
+        if (outcome.exitCode !== 0) {
+          throw new CliError(
+            outcome.exitCode === 1 ? "VALIDATION" : "RUNTIME",
+            "Project profile apply failed",
+            { silent: true }
+          );
+        }
+      }
+    );
+
   // init - Initialize GNO
   program
     .command("init [path]")
@@ -1320,6 +1393,7 @@ function wireOnboardingCommands(program: Command): void {
             | undefined,
           language: cmdOpts.language as string | undefined,
           yes: globals.yes,
+          configPath: globals.config,
         });
 
         if (!result.success) {
@@ -1367,13 +1441,20 @@ function wireOnboardingCommands(program: Command): void {
       collectRepeatableValue,
       []
     )
+    .option(
+      "--apply-profile",
+      "apply a valid project profile before lexical setup"
+    )
     .option("--no-semantic", "skip background semantic indexing")
     .option("--json", "JSON output")
     .action(async (folder: string, cmdOpts: Record<string, unknown>) => {
       const globals = getGlobals();
       const json = Boolean(cmdOpts.json) || globals.json;
-      const { formatSetupOutputResult, setupWithActivation } =
-        await import("./commands/setup-activation");
+      const {
+        formatSetupOutputResult,
+        formatSetupProfileAdvisory,
+        setupWithActivation,
+      } = await import("./commands/setup-activation");
       const exclusions = cmdOpts.exclude as string[];
       const outcome = await setupWithActivation({
         folder,
@@ -1381,6 +1462,7 @@ function wireOnboardingCommands(program: Command): void {
         exclude: exclusions.length > 0 ? exclusions : undefined,
         authorizeSecretRisk: Boolean(cmdOpts.authorizeSecretRisk),
         connectorIds: cmdOpts.connector as string[],
+        applyProfile: Boolean(cmdOpts.applyProfile),
         semantic: cmdOpts.semantic !== false,
         indexName: globals.index,
         configPath: globals.config,
@@ -1391,6 +1473,17 @@ function wireOnboardingCommands(program: Command): void {
         progress: (stage) => {
           process.stderr.write(`setup: ${stage}\n`);
         },
+        onProfileAdvisory: (profile) => {
+          if (json || globals.quiet) return;
+          const advisory = formatSetupProfileAdvisory(profile, {
+            applyRequested: Boolean(cmdOpts.applyProfile),
+          });
+          if (advisory) process.stderr.write(`${advisory}\n`);
+        },
+        onProfileApply: (profile) => {
+          if (json || globals.quiet) return;
+          process.stderr.write(`setup: project profile ${profile.status}\n`);
+        },
       });
       const output = formatSetupOutputResult(outcome.result, { json });
       if (json || outcome.exitCode === 0) {
@@ -1958,6 +2051,7 @@ function wireManagementCommands(program: Command): void {
         include: cmdOpts.include as string | undefined,
         exclude: cmdOpts.exclude as string | undefined,
         update: cmdOpts.update as string | undefined,
+        configPath: getGlobals().config,
       });
     });
 
@@ -1982,7 +2076,7 @@ function wireManagementCommands(program: Command): void {
     .description("Remove a collection")
     .action(async (name: string) => {
       const { collectionRemove } = await import("./commands/collection");
-      await collectionRemove(name);
+      await collectionRemove(name, { configPath: getGlobals().config });
     });
 
   collectionCmd
@@ -1990,7 +2084,9 @@ function wireManagementCommands(program: Command): void {
     .description("Rename a collection")
     .action(async (oldName: string, newName: string) => {
       const { collectionRename } = await import("./commands/collection");
-      await collectionRename(oldName, newName);
+      await collectionRename(oldName, newName, {
+        configPath: getGlobals().config,
+      });
     });
 
   collectionCmd
@@ -2017,9 +2113,11 @@ function wireManagementCommands(program: Command): void {
     .description("Add context metadata for a scope")
     .action(async (scope: string, text: string) => {
       const { contextAdd } = await import("./commands/context");
-      const exitCode = await contextAdd(scope, text);
+      const exitCode = await contextAdd(scope, text, {
+        configPath: getGlobals().config,
+      });
       if (exitCode !== 0) {
-        throw new CliError("RUNTIME", "Failed to add context");
+        throw new CliError("VALIDATION", "Failed to add context");
       }
     });
 
@@ -2301,11 +2399,16 @@ function wireManagementCommands(program: Command): void {
     });
 
   contextCmd
-    .command("rm <uri>")
+    .command("rm <scope> [text]")
     .description("Remove context item")
-    .action(async (uri: string) => {
+    .action(async (scope: string, text?: string) => {
       const { contextRm } = await import("./commands/context");
-      await contextRm(uri);
+      const exitCode = await contextRm(scope, text, {
+        configPath: getGlobals().config,
+      });
+      if (exitCode !== 0) {
+        throw new CliError("VALIDATION", "Failed to remove context");
+      }
     });
 
   // models subcommands

package/src/config/content-types.ts

@@ -8,6 +8,7 @@ import type { NotePresetId } from "../core/note-presets";
 import type { Config, ContentTypeConfig } from "./types";
 
 import { NOTE_PRESETS } from "../core/note-presets";
+import { CONTENT_TYPE_SEARCH_BOOST_NEUTRAL } from "./types";
 
 export type ConfigWarningCode =
   | "UNKNOWN_CONTENT_TYPE_PRESET"
@@ -21,6 +22,7 @@ export interface ConfigWarning {
 
 export interface NormalizedContentTypeRule extends ContentTypeConfig {
   preset: NotePresetId;
+  searchBoost: number;
 }
 
 export interface ContentTypeNormalizationResult {
@@ -33,6 +35,14 @@ export interface ConfigNormalizationResult {
   warnings: ConfigWarning[];
 }
 
+export interface ContentTypeBoostStatus {
+  rulesFingerprint: string;
+  rules: Array<{
+    id: string;
+    searchBoost: number;
+  }>;
+}
+
 const NOTE_PRESET_IDS = new Set<NotePresetId>(
   NOTE_PRESETS.map((preset) => preset.id)
 );
@@ -48,6 +58,10 @@ function isNotePresetId(value: string): value is NotePresetId {
   return NOTE_PRESET_IDS.has(value as NotePresetId);
 }
 
+function normalizeSearchBoost(value: number | undefined): number {
+  return value ?? CONTENT_TYPE_SEARCH_BOOST_NEUTRAL;
+}
+
 export function normalizeContentTypes(
   contentTypes: ContentTypeConfig[]
 ): ContentTypeNormalizationResult {
@@ -89,6 +103,7 @@ export function normalizeContentTypes(
         graphHints: contentType.graphHints
           ? contentType.graphHints.map(normalizeGraphHint).filter(Boolean)
           : undefined,
+        searchBoost: normalizeSearchBoost(contentType.searchBoost),
       });
       continue;
     }
@@ -100,6 +115,7 @@ export function normalizeContentTypes(
       graphHints: contentType.graphHints
         ? contentType.graphHints.map(normalizeGraphHint).filter(Boolean)
         : undefined,
+      searchBoost: normalizeSearchBoost(contentType.searchBoost),
     });
   }
 
@@ -112,6 +128,34 @@ export function normalizeContentTypes(
   return { rules, warnings };
 }
 
+export interface ContentTypeRuleResolution {
+  rule: NormalizedContentTypeRule;
+  source: "configured-id" | "prefix";
+}
+
+/**
+ * Resolve one canonical configured rule. A configured frontmatter type wins;
+ * otherwise normalized rule order provides longest-prefix matching. Arbitrary
+ * category text is intentionally not an input and boosts never stack.
+ */
+export function resolveContentTypeRule(
+  configuredId: string | undefined,
+  relativePath: string,
+  rules: NormalizedContentTypeRule[]
+): ContentTypeRuleResolution | undefined {
+  if (configuredId) {
+    const configuredRule = rules.find((rule) => rule.id === configuredId);
+    if (configuredRule) {
+      return { rule: configuredRule, source: "configured-id" };
+    }
+  }
+
+  const prefixRule = rules.find((rule) =>
+    rule.prefixes.some((prefix) => relativePath.startsWith(prefix))
+  );
+  return prefixRule ? { rule: prefixRule, source: "prefix" } : undefined;
+}
+
 export function normalizeConfigContentTypes(
   config: Config
 ): ConfigNormalizationResult {
@@ -127,6 +171,44 @@ export function normalizeConfigContentTypes(
 
 export function fingerprintContentTypeRules(
   rules: NormalizedContentTypeRule[]
+): string {
+  const canonical = rules.map((rule) => {
+    const base = {
+      id: rule.id,
+      preset: rule.preset,
+      prefixes: rule.prefixes,
+      graphHints: rule.graphHints ?? [],
+    };
+    return rule.searchBoost === CONTENT_TYPE_SEARCH_BOOST_NEUTRAL
+      ? base
+      : { ...base, searchBoost: rule.searchBoost };
+  });
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(JSON.stringify(canonical));
+  return hasher.digest("hex");
+}
+
+/**
+ * Redacted live-ranking projection for status surfaces. Prefixes remain local
+ * configuration details; rule IDs and factors are enough to audit behavior.
+ */
+export function buildContentTypeBoostStatus(
+  contentTypes: ContentTypeConfig[]
+): ContentTypeBoostStatus {
+  const { rules } = normalizeContentTypes(contentTypes);
+  return {
+    rulesFingerprint: fingerprintContentTypeRules(rules),
+    rules: rules.map(({ id, searchBoost }) => ({ id, searchBoost })),
+  };
+}
+
+/**
+ * Fingerprint only fields that derive persisted document metadata.
+ * Search boosts are evaluated from live config at query time, so changing one
+ * must not force content conversion or vector rebuilds.
+ */
+export function fingerprintContentTypeMetadataRules(
+  rules: NormalizedContentTypeRule[]
 ): string {
   const canonical = rules.map((rule) => ({
     id: rule.id,

package/src/config/index.ts

@@ -6,13 +6,18 @@
 
 export { createDefaultConfig } from "./defaults";
 export {
+  type ContentTypeRuleResolution,
+  type ContentTypeBoostStatus,
   type ConfigWarning,
+  buildContentTypeBoostStatus,
+  fingerprintContentTypeMetadataRules,
   fingerprintContentTypeRules,
   formatConfigWarning,
   formatConfigWarnings,
   normalizeConfigContentTypes,
   normalizeContentTypes,
   type NormalizedContentTypeRule,
+  resolveContentTypeRule,
   writeConfigWarningsToStderr,
 } from "./content-types";
 // Loading
@@ -42,10 +47,14 @@ export {
   type SaveResult,
   saveConfig,
   saveConfigToPath,
+  saveTextToPath,
 } from "./saver";
 // Types and schemas
 export {
   CONFIG_VERSION,
+  CONTENT_TYPE_SEARCH_BOOST_MAX,
+  CONTENT_TYPE_SEARCH_BOOST_MIN,
+  CONTENT_TYPE_SEARCH_BOOST_NEUTRAL,
   type Collection,
   CollectionSchema,
   type Config,
@@ -66,6 +75,8 @@ export {
   getCollectionFromScope,
   isValidLanguageHint,
   parseScope,
+  type ProjectProfileBinding,
+  ProjectProfileBindingSchema,
   type ScopeType,
   ScopeTypeSchema,
 } from "./types";