@gmickel/gno 1.12.4 → 1.14.0

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

@@ -11,6 +11,12 @@ import type { DocumentRow, StorePort, StoreResult } from "../../store/types";
 import type { ParsedRef } from "./ref-parser";
 
 import { decorateUriForIndex, parseUri } from "../../app/constants";
+import {
+  canonicalizeIndexName,
+  INDEX_NAME_REQUIREMENTS,
+  indexNamesMatch,
+  isValidIndexName,
+} from "../../app/index-name";
 import { isGlobPattern, parseRef, splitRefs } from "./ref-parser";
 import { initStore } from "./shared";
 
@@ -319,7 +325,13 @@ function resolveMultiGetIndex(
   refs: string[],
   globalIndexName?: string
 ): { ok: true; indexName?: string } | { ok: false; error: string } {
-  const explicitIndexes = new Set<string>();
+  if (globalIndexName !== undefined && !isValidIndexName(globalIndexName)) {
+    return {
+      ok: false,
+      error: `Invalid index name: ${INDEX_NAME_REQUIREMENTS}.`,
+    };
+  }
+  const explicitIndexes = new Map<string, string>();
   let hasUnindexedRef = false;
 
   for (const ref of refs) {
@@ -329,8 +341,17 @@ function resolveMultiGetIndex(
       continue;
     }
     const indexName = parseUri(parsed.value)?.indexName;
-    if (indexName) {
-      explicitIndexes.add(indexName);
+    if (indexName !== undefined) {
+      if (!isValidIndexName(indexName)) {
+        return {
+          ok: false,
+          error: `Invalid index name: ${INDEX_NAME_REQUIREMENTS}.`,
+        };
+      }
+      const identity = canonicalizeIndexName(indexName);
+      if (!explicitIndexes.has(identity)) {
+        explicitIndexes.set(identity, indexName);
+      }
     } else {
       hasUnindexedRef = true;
     }
@@ -342,16 +363,20 @@ function resolveMultiGetIndex(
   if (explicitIndexes.size > 1) {
     return {
       ok: false,
-      error: `multi-get cannot mix explicit indexes: ${[...explicitIndexes].sort().join(", ")}`,
+      error: `multi-get cannot mix explicit indexes: ${[
+        ...explicitIndexes.values(),
+      ]
+        .sort()
+        .join(", ")}`,
     };
   }
 
-  const explicitIndex = [...explicitIndexes][0];
+  const explicitIndex = [...explicitIndexes.values()][0];
   if (
     hasUnindexedRef &&
     globalIndexName &&
     explicitIndex &&
-    globalIndexName !== explicitIndex
+    !indexNamesMatch(globalIndexName, explicitIndex)
   ) {
     return {
       ok: false,

package/src/cli/commands/status.ts

@@ -5,11 +5,16 @@
  * @module src/cli/commands/status
  */
 
+import type { ActivationStatus } from "../../core/activation-status";
 import type { IndexStatus } from "../../store/types";
 
-import { getIndexDbPath } from "../../app/constants";
+import { getIndexDbPath, getModelsCachePath } from "../../app/constants";
 import { getConfigPaths, isInitialized, loadConfig } from "../../config";
-import { resolveModelUri } from "../../llm/registry";
+import { isConnectorActivationComplete } from "../../core/activation-connector-health";
+import { buildActivationStatus } from "../../core/activation-status";
+import { ModelCache } from "../../llm/cache";
+import { getActivePreset, resolveModelUri } from "../../llm/registry";
+import { getConnectorVerificationTargets } from "../../serve/connectors";
 import { SqliteAdapter } from "../../store/sqlite/adapter";
 
 /**
@@ -30,13 +35,35 @@ export interface StatusOptions {
  * Result of status command.
  */
 export type StatusResult =
-  | { success: true; status: IndexStatus }
+  | { success: true; status: IndexStatus; activation: ActivationStatus }
   | { success: false; error: string };
 
+function connectorProjectionLine(activation: ActivationStatus): string | null {
+  const { projected, total, truncated } = activation.connectorProjection;
+  if (!truncated) {
+    return null;
+  }
+  return `Connector projection: ${projected}/${total} target/collection checks shown; ${total - projected} omitted`;
+}
+
+function isStatusHealthy(
+  indexStatus: IndexStatus,
+  activation: ActivationStatus
+): boolean {
+  return (
+    indexStatus.healthy &&
+    activation.healthy &&
+    isConnectorActivationComplete(activation)
+  );
+}
+
 /**
  * Format status as terminal output.
  */
-function formatTerminal(indexStatus: IndexStatus): string {
+function formatTerminal(
+  indexStatus: IndexStatus,
+  activation: ActivationStatus
+): string {
   const lines: string[] = [];
 
   lines.push(`Index: ${indexStatus.indexName}`);
@@ -73,7 +100,34 @@ function formatTerminal(indexStatus: IndexStatus): string {
     lines.push(`Last updated: ${indexStatus.lastUpdatedAt}`);
   }
 
-  lines.push(`Health: ${indexStatus.healthy ? "OK" : "DEGRADED"}`);
+  lines.push(
+    `Health: ${isStatusHealthy(indexStatus, activation) ? "OK" : "DEGRADED"}`
+  );
+  lines.push("");
+  lines.push(
+    `Lexical activation: ${activation.healthy ? "READY" : activation.usable ? "DEGRADED" : "BLOCKED"}`
+  );
+  for (const collection of activation.collections) {
+    const failedStage = collection.remediation?.stage;
+    const suffix = failedStage
+      ? ` (${failedStage}: ${collection.remediation?.code}; ${collection.remediation?.command})`
+      : ` (semantic: ${collection.semanticAvailability.code})`;
+    lines.push(
+      `  ${collection.collection}: ${collection.ready ? "lexical ready" : "not ready"}${suffix}`
+    );
+  }
+  if (activation.connectors.length > 0) {
+    lines.push("Connector proofs:");
+    for (const connector of activation.connectors) {
+      lines.push(
+        `  ${connector.target}/${connector.collection}: ${connector.status}${connector.code ? ` (${connector.code})` : ""}`
+      );
+    }
+  }
+  const projectionLine = connectorProjectionLine(activation);
+  if (projectionLine) {
+    lines.push(projectionLine);
+  }
 
   return lines.join("\n");
 }
@@ -81,14 +135,19 @@ function formatTerminal(indexStatus: IndexStatus): string {
 /**
  * Format status as Markdown.
  */
-function formatMarkdown(indexStatus: IndexStatus): string {
+function formatMarkdown(
+  indexStatus: IndexStatus,
+  activation: ActivationStatus
+): string {
   const lines: string[] = [];
 
   lines.push(`# Index Status: ${indexStatus.indexName}`);
   lines.push("");
   lines.push(`- **Config**: ${indexStatus.configPath}`);
   lines.push(`- **Database**: ${indexStatus.dbPath}`);
-  lines.push(`- **Health**: ${indexStatus.healthy ? "✓ OK" : "⚠ DEGRADED"}`);
+  lines.push(
+    `- **Health**: ${isStatusHealthy(indexStatus, activation) ? "✓ OK" : "⚠ DEGRADED"}`
+  );
   lines.push("");
 
   if (indexStatus.collections.length > 0) {
@@ -115,6 +174,26 @@ function formatMarkdown(indexStatus: IndexStatus): string {
     lines.push(`- **Last updated**: ${indexStatus.lastUpdatedAt}`);
   }
 
+  lines.push("");
+  lines.push("## Lexical activation");
+  lines.push("");
+  lines.push(`- **Usable**: ${activation.usable}`);
+  lines.push(`- **Lexically healthy**: ${activation.healthy}`);
+  for (const collection of activation.collections) {
+    lines.push(
+      `- **${collection.collection}**: ${collection.ready ? "lexical ready" : `${collection.remediation?.stage ?? "index"} ${collection.remediation?.code ?? "index_query_failed"}`}`
+    );
+  }
+  for (const connector of activation.connectors) {
+    lines.push(
+      `- **${connector.target}/${connector.collection}**: ${connector.status}${connector.code ? ` (${connector.code})` : ""}`
+    );
+  }
+  const projectionLine = connectorProjectionLine(activation);
+  if (projectionLine) {
+    lines.push(`- **${projectionLine}**`);
+  }
+
   return lines.join("\n");
 }
 
@@ -158,7 +237,23 @@ export async function status(
       return { success: false, error: statusResult.error.message };
     }
 
-    return { success: true, status: statusResult.value };
+    const preset = getActivePreset(config);
+    const embedModelCached = await new ModelCache(
+      getModelsCachePath()
+    ).isCached(preset.embed);
+    const activation = await buildActivationStatus(
+      store,
+      config.collections.map(({ name }) => name),
+      {
+        semantic: {
+          modelsCached: embedModelCached,
+          embeddingBacklog: statusResult.value.embeddingBacklog,
+        },
+        connectorTargets: await getConnectorVerificationTargets(),
+      }
+    );
+
+    return { success: true, status: statusResult.value, activation };
   } finally {
     await store.close();
   }
@@ -196,7 +291,8 @@ export function formatStatus(
         totalChunks: s.totalChunks,
         embeddingBacklog: s.embeddingBacklog,
         lastUpdated: s.lastUpdatedAt,
-        healthy: s.healthy,
+        healthy: isStatusHealthy(s, result.activation),
+        activation: result.activation,
       },
       null,
       2
@@ -204,8 +300,8 @@ export function formatStatus(
   }
 
   if (options.md) {
-    return formatMarkdown(result.status);
+    return formatMarkdown(result.status, result.activation);
   }
 
-  return formatTerminal(result.status);
+  return formatTerminal(result.status, result.activation);
 }

package/src/cli/program.ts

@@ -18,6 +18,7 @@ import {
   PRODUCT_NAME,
   VERSION,
 } from "../app/constants";
+import { INDEX_NAME_REQUIREMENTS, isValidIndexName } from "../app/index-name";
 import { resolveDepthPolicy } from "../core/depth-policy";
 import { parseAndValidateTagFilter } from "../core/tags";
 import { setColorsEnabled } from "./colors";
@@ -240,6 +241,12 @@ export function createProgram(): Command {
   program.hook("preAction", (thisCommand) => {
     const rootOpts = thisCommand.optsWithGlobals();
     const globals = parseGlobalOptions(rootOpts);
+    if (!isValidIndexName(globals.index)) {
+      throw new CliError(
+        "VALIDATION",
+        `Invalid index name: ${INDEX_NAME_REQUIREMENTS}.`
+      );
+    }
     applyGlobalOptions(globals);
     globalState.current = globals;
   });
@@ -1045,13 +1052,23 @@ function wireOnboardingCommands(program: Command): void {
     .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const format = getFormat(cmdOpts);
-      const { doctor, formatDoctor } = await import("./commands/doctor");
-      const result = await doctor({ json: format === "json" });
+      const { doctor, formatDoctor, hasCriticalDoctorErrors } =
+        await import("./commands/doctor");
+      const globals = getGlobals();
+      const result = await doctor({
+        configPath: globals.config,
+        indexName: globals.index,
+        json: format === "json",
+      });
 
-      // Doctor always succeeds but may report issues
       process.stdout.write(
         `${formatDoctor(result, { json: format === "json" })}\n`
       );
+      if (hasCriticalDoctorErrors(result.checks)) {
+        throw new CliError("RUNTIME", "Critical health checks failed", {
+          silent: true,
+        });
+      }
     });
 }
 
@@ -1308,8 +1325,7 @@ function wireMcpCommand(program: Command): void {
     )
     .option(
       "-s, --scope <scope>",
-      "scope (user, project) - project only for claude-code/codex/cursor/opencode",
-      "user"
+      "scope (user, project) - defaults to project for LibreChat and user otherwise"
     )
     .option("-f, --force", "overwrite existing configuration")
     .option("--dry-run", "show what would be done without making changes")
@@ -1320,10 +1336,11 @@ function wireMcpCommand(program: Command): void {
     .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const target = cmdOpts.target as string;
-      const scope = cmdOpts.scope as string;
+      const requestedScope = cmdOpts.scope;
 
       // Import MCP_TARGETS for validation
-      const { MCP_TARGETS } = await import("./commands/mcp/paths.js");
+      const { getDefaultTargetScope, MCP_TARGETS } =
+        await import("./commands/mcp/paths.js");
 
       // Validate target
       if (!(MCP_TARGETS as string[]).includes(target)) {
@@ -1332,15 +1349,26 @@ function wireMcpCommand(program: Command): void {
           `Invalid target: ${target}. Must be one of: ${MCP_TARGETS.join(", ")}.`
         );
       }
-      // Validate scope
-      if (!["user", "project"].includes(scope)) {
+      // Validate an explicit scope, then let the target choose its default.
+      if (
+        requestedScope !== undefined &&
+        (typeof requestedScope !== "string" ||
+          !["user", "project"].includes(requestedScope))
+      ) {
         throw new CliError(
           "VALIDATION",
-          `Invalid scope: ${scope}. Must be 'user' or 'project'.`
+          `Invalid scope: ${JSON.stringify(requestedScope)}. Must be 'user' or 'project'.`
         );
       }
+      const scope =
+        typeof requestedScope === "string"
+          ? requestedScope
+          : getDefaultTargetScope(
+              target as Parameters<typeof getDefaultTargetScope>[0]
+            );
 
       const { installMcp } = await import("./commands/mcp/install.js");
+      const globals = getGlobals();
       await installMcp({
         target: target as NonNullable<
           Parameters<typeof installMcp>[0]
@@ -1349,6 +1377,8 @@ function wireMcpCommand(program: Command): void {
         force: Boolean(cmdOpts.force),
         dryRun: Boolean(cmdOpts.dryRun),
         enableWrite: Boolean(cmdOpts.enableWrite),
+        indexName: globals.index,
+        configPath: globals.config,
         // Pass undefined if not set, so global --json can take effect
         json: cmdOpts.json === true ? true : undefined,
       });
@@ -1363,14 +1393,18 @@ function wireMcpCommand(program: Command): void {
       "target client (claude-desktop, cursor, zed, windsurf, opencode, amp, lmstudio, librechat, claude-code, codex)",
       "claude-desktop"
     )
-    .option("-s, --scope <scope>", "scope (user, project)", "user")
+    .option(
+      "-s, --scope <scope>",
+      "scope (user, project) - defaults to project for LibreChat and user otherwise"
+    )
     .option("--json", "JSON output")
     .action(async (cmdOpts: Record<string, unknown>) => {
       const target = cmdOpts.target as string;
-      const scope = cmdOpts.scope as string;
+      const requestedScope = cmdOpts.scope;
 
       // Import MCP_TARGETS for validation
-      const { MCP_TARGETS } = await import("./commands/mcp/paths.js");
+      const { getDefaultTargetScope, MCP_TARGETS } =
+        await import("./commands/mcp/paths.js");
 
       // Validate target
       if (!(MCP_TARGETS as string[]).includes(target)) {
@@ -1379,13 +1413,23 @@ function wireMcpCommand(program: Command): void {
           `Invalid target: ${target}. Must be one of: ${MCP_TARGETS.join(", ")}.`
         );
       }
-      // Validate scope
-      if (!["user", "project"].includes(scope)) {
+      // Validate an explicit scope, then let the target choose its default.
+      if (
+        requestedScope !== undefined &&
+        (typeof requestedScope !== "string" ||
+          !["user", "project"].includes(requestedScope))
+      ) {
         throw new CliError(
           "VALIDATION",
-          `Invalid scope: ${scope}. Must be 'user' or 'project'.`
+          `Invalid scope: ${JSON.stringify(requestedScope)}. Must be 'user' or 'project'.`
         );
       }
+      const scope =
+        typeof requestedScope === "string"
+          ? requestedScope
+          : getDefaultTargetScope(
+              target as Parameters<typeof getDefaultTargetScope>[0]
+            );
 
       const { uninstallMcp } = await import("./commands/mcp/uninstall.js");
       await uninstallMcp({
@@ -1418,7 +1462,7 @@ function wireMcpCommand(program: Command): void {
       const scope = cmdOpts.scope as string;
 
       // Import MCP_TARGETS for validation
-      const { MCP_TARGETS, TARGETS_WITH_PROJECT_SCOPE } =
+      const { getTargetDisplayName, getTargetScopes, MCP_TARGETS } =
         await import("./commands/mcp/paths.js");
 
       // Validate target
@@ -1438,12 +1482,14 @@ function wireMcpCommand(program: Command): void {
       // Validate target/scope combination
       if (
         target !== "all" &&
-        scope === "project" &&
-        !(TARGETS_WITH_PROJECT_SCOPE as string[]).includes(target)
+        scope !== "all" &&
+        !getTargetScopes(
+          target as Parameters<typeof getTargetScopes>[0]
+        ).includes(scope as "user" | "project")
       ) {
         throw new CliError(
           "VALIDATION",
-          `${target} does not support project scope.`
+          `${getTargetDisplayName(target as Parameters<typeof getTargetDisplayName>[0])} does not support ${scope} scope.`
         );
       }
 

package/src/core/activation-connector-health.ts

@@ -0,0 +1,19 @@
+import type { ActivationStatus } from "./activation-status";
+
+const NON_RUNTIME_CODES = new Set([
+  "connector_not_configured",
+  "target_runtime_unverifiable",
+]);
+
+/** True when every observable proof passed and no target/collection pair was omitted. */
+export function isConnectorActivationComplete(
+  activation: ActivationStatus
+): boolean {
+  if (activation.connectorProjection.truncated) {
+    return false;
+  }
+  return activation.connectors.every(
+    ({ code, status }) =>
+      (code !== undefined && NON_RUNTIME_CODES.has(code)) || status === "passed"
+  );
+}