@gmickel/gno 1.22.0 → 1.24.0

package/src/cli/commands/context-build.ts

@@ -1,6 +1,7 @@
 /** Context Capsule build command over the shared application runtime. */
 
 import type { ContextCapsuleBuildInput } from "../../app/context-runtime";
+import type { CliProjectAffinityRequest } from "../../core/project-affinity-surface";
 import type { RetrievalTraceSession } from "../../core/retrieval-trace-session";
 import type { EmbeddingPort, RerankPort } from "../../llm/types";
 import type { VectorIndexPort } from "../../store/vector";
@@ -11,6 +12,7 @@ import {
   canonicalBuiltContextCapsuleJson,
   validateContextCapsuleBuildInput,
 } from "../../app/context-runtime";
+import { resolveCliProjectAffinity } from "../../core/project-affinity-surface";
 import {
   finishRetrievalTraceAfterError,
   startRetrievalTraceRequest,
@@ -27,10 +29,8 @@ import {
 } from "../progress";
 import { initStore } from "./shared";
 
-export interface ContextBuildCommandOptions extends Omit<
-  ContextCapsuleBuildInput,
-  "goal"
-> {
+export interface ContextBuildCommandOptions
+  extends Omit<ContextCapsuleBuildInput, "goal">, CliProjectAffinityRequest {
   configPath?: string;
   format: "json" | "md";
 }
@@ -64,8 +64,12 @@ export const contextBuild = async (
   goal: string,
   options: ContextBuildCommandOptions
 ): Promise<string> => {
+  const { projectAffinityDisabled, projectRoots, ...contextOptions } = options;
   try {
-    validateContextCapsuleBuildInput({ goal, ...options }, options.indexName);
+    validateContextCapsuleBuildInput(
+      { goal, ...contextOptions },
+      options.indexName
+    );
   } catch (error) {
     throw contextCliError(error);
   }
@@ -84,8 +88,13 @@ export const contextBuild = async (
   let vectorIndex: VectorIndexPort | null = null;
   let traceSession: RetrievalTraceSession | undefined;
   try {
+    const projectAffinity = await resolveCliProjectAffinity(config, {
+      cwd: process.cwd(),
+      disabled: projectAffinityDisabled,
+      projectRoots,
+    });
     validateContextCapsuleBuildInput(
-      { goal, ...options },
+      { goal, ...contextOptions },
       options.indexName,
       config.collections.map((collection) => collection.name)
     );
@@ -163,7 +172,7 @@ export const contextBuild = async (
       if (showProgress && progress) process.stderr.write("\n");
     }
     const capsule = await buildContextCapsule(
-      { goal, ...options },
+      { goal, ...contextOptions },
       {
         store,
         config,
@@ -171,6 +180,7 @@ export const contextBuild = async (
         vectorIndex,
         embedPort,
         rerankPort,
+        projectAffinity,
         traceSession,
       }
     );

package/src/cli/commands/embed.ts

@@ -68,6 +68,8 @@ export interface EmbedOptions {
   json?: boolean;
   /** Verbose error logging */
   verbose?: boolean;
+  /** Use cached models only (also used by the standalone setup worker). */
+  offline?: boolean;
 }
 
 export type EmbedResult =
@@ -469,9 +471,12 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
     }
 
     // Create LLM adapter and embedding port with auto-download
-    const globals = getGlobals();
+    let offline = options.offline;
+    if (offline === undefined) {
+      offline = getGlobals().offline;
+    }
     const policy = resolveDownloadPolicy(process.env, {
-      offline: globals.offline,
+      offline,
     });
 
     // Create progress renderer for model download (throttled to avoid spam)

package/src/cli/commands/query.ts

@@ -5,6 +5,7 @@
  * @module src/cli/commands/query
  */
 
+import type { CliProjectAffinityRequest } from "../../core/project-affinity-surface";
 import type { RetrievalTraceSurfaceMetadata } from "../../core/retrieval-trace-session";
 import type { RetrievalTraceSession } from "../../core/retrieval-trace-session";
 import type {
@@ -18,6 +19,7 @@ import {
   fingerprintContentTypeRules,
   normalizeContentTypes,
 } from "../../config";
+import { resolveCliProjectAffinity } from "../../core/project-affinity-surface";
 import {
   finishRetrievalTraceAfterError,
   retrievalTraceFilters,
@@ -46,30 +48,31 @@ import { decorateSearchResultsForIndex, initStore } from "./shared";
 // Types
 // ─────────────────────────────────────────────────────────────────────────────
 
-export type QueryCommandOptions = HybridSearchOptions & {
-  /** Override config path */
-  configPath?: string;
-  /** Index name */
-  indexName?: string;
-  /** Override embedding model */
-  embedModel?: string;
-  /** Override expansion model */
-  expandModel?: string;
-  /** Deprecated alias for expansion model */
-  genModel?: string;
-  /** Override rerank model */
-  rerankModel?: string;
-  /** Output as JSON */
-  json?: boolean;
-  /** Output as Markdown */
-  md?: boolean;
-  /** Output as CSV */
-  csv?: boolean;
-  /** Output as XML */
-  xml?: boolean;
-  /** Output files only */
-  files?: boolean;
-};
+export type QueryCommandOptions = Omit<HybridSearchOptions, "projectAffinity"> &
+  CliProjectAffinityRequest & {
+    /** Override config path */
+    configPath?: string;
+    /** Index name */
+    indexName?: string;
+    /** Override embedding model */
+    embedModel?: string;
+    /** Override expansion model */
+    expandModel?: string;
+    /** Deprecated alias for expansion model */
+    genModel?: string;
+    /** Override rerank model */
+    rerankModel?: string;
+    /** Output as JSON */
+    json?: boolean;
+    /** Output as Markdown */
+    md?: boolean;
+    /** Output as CSV */
+    csv?: boolean;
+    /** Output as XML */
+    xml?: boolean;
+    /** Output files only */
+    files?: boolean;
+  };
 
 export interface QueryFormatOptions {
   format: "terminal" | "json" | "files" | "csv" | "md" | "xml";
@@ -86,16 +89,20 @@ export type QueryResult =
     }
   | { success: false; error: string };
 
-export type QueryDiagnoseCommandOptions = HybridSearchOptions & {
-  target: string;
-  configPath?: string;
-  indexName?: string;
-  embedModel?: string;
-  expandModel?: string;
-  genModel?: string;
-  rerankModel?: string;
-  json?: boolean;
-};
+export type QueryDiagnoseCommandOptions = Omit<
+  HybridSearchOptions,
+  "projectAffinity"
+> &
+  CliProjectAffinityRequest & {
+    target: string;
+    configPath?: string;
+    indexName?: string;
+    embedModel?: string;
+    expandModel?: string;
+    genModel?: string;
+    rerankModel?: string;
+    json?: boolean;
+  };
 
 export interface QueryDiagnoseFormatOptions {
   format: "terminal" | "json";
@@ -140,6 +147,12 @@ export async function query(
   let traceSession: RetrievalTraceSession | undefined;
 
   try {
+    const { projectAffinityDisabled, projectRoots, ...queryOptions } = options;
+    const projectAffinity = await resolveCliProjectAffinity(config, {
+      cwd: process.cwd(),
+      disabled: projectAffinityDisabled,
+      projectRoots,
+    });
     const embedUri = resolveModelUri(
       config,
       "embed",
@@ -167,7 +180,7 @@ export async function query(
       store,
       config,
       query: queryText,
-      filters: retrievalTraceFilters({ ...options, limit }),
+      filters: retrievalTraceFilters({ ...queryOptions, limit }),
       pipeline: "hybrid",
       indexName: options.indexName,
       modelUris: [embedUri, expandUri, rerankUri].filter(
@@ -261,8 +274,9 @@ export async function query(
       rerankPort,
     };
     const result = await searchHybrid(deps, queryText, {
-      ...options,
+      ...queryOptions,
       limit,
+      projectAffinity,
       traceSession,
     });
 
@@ -318,6 +332,12 @@ export async function queryDiagnose(
   let rerankPort: RerankPort | null = null;
 
   try {
+    const { projectAffinityDisabled, projectRoots, ...queryOptions } = options;
+    const projectAffinity = await resolveCliProjectAffinity(config, {
+      cwd: process.cwd(),
+      disabled: projectAffinityDisabled,
+      projectRoots,
+    });
     const globals = getGlobals();
     const policy = resolveDownloadPolicy(process.env, {
       offline: globals.offline,
@@ -415,7 +435,8 @@ export async function queryDiagnose(
       rerankPort,
     };
     const result = await diagnoseQueryTarget(deps, queryText, {
-      ...options,
+      ...queryOptions,
+      projectAffinity,
       contentTypeRules,
       contentTypeRulesFingerprint:
         fingerprintContentTypeRules(contentTypeRules),

package/src/cli/commands/search.ts

@@ -5,12 +5,14 @@
  * @module src/cli/commands/search
  */
 
+import type { CliProjectAffinityRequest } from "../../core/project-affinity-surface";
 import type {
   RetrievalTraceSession,
   RetrievalTraceSurfaceMetadata,
 } from "../../core/retrieval-trace-session";
 import type { SearchOptions, SearchResults } from "../../pipeline/types";
 
+import { resolveCliProjectAffinity } from "../../core/project-affinity-surface";
 import {
   finishRetrievalTraceAfterError,
   startRetrievalTraceRequest,
@@ -26,24 +28,25 @@ import { decorateSearchResultsForIndex, initStore } from "./shared";
 // Types
 // ─────────────────────────────────────────────────────────────────────────────
 
-export type SearchCommandOptions = SearchOptions & {
-  /** Override config path */
-  configPath?: string;
-  /** Index name */
-  indexName?: string;
-  /** Output as JSON */
-  json?: boolean;
-  /** Output as Markdown */
-  md?: boolean;
-  /** Output as CSV */
-  csv?: boolean;
-  /** Output as XML */
-  xml?: boolean;
-  /** Output files only */
-  files?: boolean;
-  /** Terminal hyperlink policy */
-  terminalLinks?: FormatOptions["terminalLinks"];
-};
+export type SearchCommandOptions = Omit<SearchOptions, "projectAffinity"> &
+  CliProjectAffinityRequest & {
+    /** Override config path */
+    configPath?: string;
+    /** Index name */
+    indexName?: string;
+    /** Output as JSON */
+    json?: boolean;
+    /** Output as Markdown */
+    md?: boolean;
+    /** Output as CSV */
+    csv?: boolean;
+    /** Output as XML */
+    xml?: boolean;
+    /** Output files only */
+    files?: boolean;
+    /** Terminal hyperlink policy */
+    terminalLinks?: FormatOptions["terminalLinks"];
+  };
 
 export type SearchResult =
   | {
@@ -84,6 +87,12 @@ export async function search(
   let traceSession: RetrievalTraceSession | undefined;
 
   try {
+    const { projectAffinityDisabled, projectRoots, ...searchOptions } = options;
+    const projectAffinity = await resolveCliProjectAffinity(config, {
+      cwd: process.cwd(),
+      disabled: projectAffinityDisabled,
+      projectRoots,
+    });
     const started = await startRetrievalTraceRequest({
       store,
       config,
@@ -109,8 +118,9 @@ export async function search(
     if (!started.ok) return { success: false, error: started.error.message };
     traceSession = started.value ?? undefined;
     const result = await searchBm25(store, query, {
-      ...options,
+      ...searchOptions,
       limit,
+      projectAffinity,
       traceSession,
     });
 

package/src/cli/commands/setup-activation.ts

@@ -0,0 +1,324 @@
+import type {
+  SetupConnectorCompositionDeps,
+  SetupConnectorDefinition,
+  SetupConnectorResult,
+  SetupConnectorState,
+} from "../../core/setup-activation";
+import type { SqliteAdapter } from "../../store/sqlite/adapter";
+import type {
+  SetupCommandOptions,
+  SetupCommandOutcome,
+  SetupCommandResult,
+} from "./setup";
+
+import { getIndexDbPath } from "../../app/constants";
+import { getConfigPaths, loadConfig, toAbsolutePath } from "../../config";
+import {
+  composeSetupConnectors,
+  SETUP_ACTIVATION_SCHEMA_VERSION,
+  unavailableSetupConnectorComposition,
+} from "../../core/setup-activation";
+import {
+  getConnectorDefinition,
+  getConnectorStatuses,
+  installConnector,
+  verifyInstalledConnector,
+} from "../../serve/connectors";
+import { SqliteAdapter as DefaultSqliteAdapter } from "../../store/sqlite/adapter";
+import {
+  formatSetupResult,
+  lexicalSuccessIsProven,
+  SETUP_COMMAND_SCHEMA_VERSION,
+  setup,
+} from "./setup";
+
+export interface SetupActivationResult {
+  schemaVersion: typeof SETUP_ACTIVATION_SCHEMA_VERSION;
+  status: "completed" | "completed_with_actions" | "failed";
+  setup: SetupCommandResult;
+  connectors: SetupConnectorResult[];
+}
+
+export type SetupOutputResult = SetupCommandResult | SetupActivationResult;
+
+export interface SetupOutputOutcome {
+  result: SetupOutputResult;
+  exitCode: 0 | 1 | 2;
+}
+
+export interface SetupProfileAdvisoryInput {
+  folder: string;
+  collection: string;
+}
+
+export interface SetupActivationCommandOptions extends SetupCommandOptions {
+  connectorIds?: string[];
+  connectorWorkspace?: { cwd?: string; homeDir?: string };
+  connectorDeps?: SetupConnectorCompositionDeps;
+  createActivationStore?: () => SqliteAdapter;
+  discoverProfileAdvisory?: (
+    input: SetupProfileAdvisoryInput
+  ) => Promise<unknown>;
+}
+
+function dedupeConnectorIds(connectorIds: string[]): string[] {
+  return [...new Set(connectorIds)];
+}
+
+function connectorStateFromStatus(
+  status: Awaited<ReturnType<typeof getConnectorStatuses>>[number]
+): SetupConnectorState {
+  return {
+    id: status.id,
+    kind: status.installKind,
+    target: status.target,
+    scope: status.scope,
+    installed: status.installed,
+    configurationError: Boolean(status.error),
+  };
+}
+
+function connectorDefinitions(
+  connectorIds: string[]
+): SetupConnectorDefinition[] | null {
+  const definitions: SetupConnectorDefinition[] = [];
+  for (const connectorId of connectorIds) {
+    const definition = getConnectorDefinition(connectorId);
+    if (!definition) {
+      return null;
+    }
+    definitions.push(definition);
+  }
+  return definitions;
+}
+
+function invalidConnectorOutcome(connectorIds: string[]): SetupCommandOutcome {
+  const unknown = connectorIds.find(
+    (connectorId) => getConnectorDefinition(connectorId) === null
+  );
+  return {
+    result: {
+      schemaVersion: SETUP_COMMAND_SCHEMA_VERSION,
+      status: "failed",
+      lexical: {
+        receipt: null,
+        error: {
+          code: "invalid_connector",
+          message: `Unknown connector: ${unknown ?? ""}`.trim(),
+          remediation:
+            "Run `gno setup --help` and pass one documented connector ID.",
+        },
+      },
+      semantic: null,
+    },
+    exitCode: 1,
+  };
+}
+
+function failedSetupActivationOutcome(
+  setupOutcome: SetupCommandOutcome
+): SetupOutputOutcome {
+  return {
+    result: {
+      schemaVersion: SETUP_ACTIVATION_SCHEMA_VERSION,
+      status: "failed",
+      setup: setupOutcome.result,
+      connectors: [],
+    },
+    exitCode: setupOutcome.exitCode,
+  };
+}
+
+function defaultConnectorDeps(
+  workspace: { cwd?: string; homeDir?: string } | undefined
+): SetupConnectorCompositionDeps {
+  return {
+    getStates: async () =>
+      (await getConnectorStatuses(workspace)).map(connectorStateFromStatus),
+    install: async (connectorId, context) =>
+      connectorStateFromStatus(
+        await installConnector(
+          connectorId,
+          { reinstall: false },
+          {
+            ...workspace,
+            indexName: context.indexName,
+            configPath: context.configPath,
+          }
+        )
+      ),
+    verify: async (connectorId, store, collection) =>
+      verifyInstalledConnector(
+        connectorId,
+        store,
+        collection,
+        undefined,
+        workspace
+      ),
+  };
+}
+
+async function discoverProfileAdvisory(
+  discover: SetupActivationCommandOptions["discoverProfileAdvisory"],
+  input: SetupProfileAdvisoryInput
+): Promise<void> {
+  if (!discover) {
+    return;
+  }
+  try {
+    await discover(input);
+  } catch {
+    // Advisory discovery cannot mutate or fail verified setup.
+  }
+}
+
+function withUnavailableConnectors(
+  setupResult: SetupCommandResult,
+  definitions: SetupConnectorDefinition[]
+): SetupOutputOutcome {
+  const unavailable = unavailableSetupConnectorComposition(definitions);
+  return {
+    result: {
+      schemaVersion: SETUP_ACTIVATION_SCHEMA_VERSION,
+      status: unavailable.status,
+      setup: setupResult,
+      connectors: unavailable.connectors,
+    },
+    exitCode: 0,
+  };
+}
+
+async function closeActivationStore(
+  store: SqliteAdapter | null
+): Promise<void> {
+  if (!store) {
+    return;
+  }
+  try {
+    await store.close();
+  } catch {
+    // Connector cleanup cannot replace proven lexical success.
+  }
+}
+
+/**
+ * Add opt-in connector onboarding beside the unchanged setup result.
+ * No-connector calls retain setup-command-result@1.0; connector-mode failures
+ * wrap the unchanged failed setup result without running connector actions.
+ */
+export async function setupWithActivation(
+  options: SetupActivationCommandOptions
+): Promise<SetupOutputOutcome> {
+  const requestedIds = dedupeConnectorIds(options.connectorIds ?? []);
+  const definitions = connectorDefinitions(requestedIds);
+  if (!definitions) {
+    return failedSetupActivationOutcome(invalidConnectorOutcome(requestedIds));
+  }
+
+  const {
+    connectorIds: _connectorIds,
+    connectorWorkspace: _connectorWorkspace,
+    connectorDeps: _connectorDeps,
+    createActivationStore: _createActivationStore,
+    discoverProfileAdvisory: _discoverProfileAdvisory,
+    ...setupOptions
+  } = options;
+  const setupOutcome = await setup(setupOptions);
+  if (
+    setupOutcome.exitCode !== 0 ||
+    setupOutcome.result.status !== "completed"
+  ) {
+    return definitions.length > 0
+      ? failedSetupActivationOutcome(setupOutcome)
+      : setupOutcome;
+  }
+
+  const lexicalReceipt = setupOutcome.result.lexical.receipt;
+  const collection = lexicalReceipt?.collection.name;
+  if (
+    !lexicalReceipt ||
+    !collection ||
+    !lexicalSuccessIsProven(lexicalReceipt)
+  ) {
+    return setupOutcome;
+  }
+
+  await discoverProfileAdvisory(options.discoverProfileAdvisory, {
+    folder: lexicalReceipt.input.folder,
+    collection,
+  });
+  if (definitions.length === 0) {
+    return setupOutcome;
+  }
+
+  let store: SqliteAdapter | null = null;
+  try {
+    const paths = getConfigPaths();
+    const configPath = toAbsolutePath(options.configPath ?? paths.configFile);
+    const indexName = options.indexName ?? "default";
+    const configResult = await loadConfig(configPath);
+    if (!configResult.ok) {
+      return withUnavailableConnectors(setupOutcome.result, definitions);
+    }
+
+    store =
+      options.createActivationStore?.() ??
+      (new DefaultSqliteAdapter() as SqliteAdapter);
+    store.setConfigPath(configPath);
+    const opened = await store.open(
+      getIndexDbPath(indexName),
+      configResult.value.ftsTokenizer
+    );
+    if (!opened.ok) {
+      return withUnavailableConnectors(setupOutcome.result, definitions);
+    }
+
+    const composition = await composeSetupConnectors({
+      connectorIds: requestedIds,
+      definitions,
+      collection,
+      store,
+      installContext: { indexName, configPath },
+      deps:
+        options.connectorDeps ??
+        defaultConnectorDeps(options.connectorWorkspace),
+    });
+    return {
+      result: {
+        schemaVersion: SETUP_ACTIVATION_SCHEMA_VERSION,
+        status: composition.status,
+        setup: setupOutcome.result,
+        connectors: composition.connectors,
+      },
+      exitCode: 0,
+    };
+  } catch {
+    return withUnavailableConnectors(setupOutcome.result, definitions);
+  } finally {
+    await closeActivationStore(store);
+  }
+}
+
+function isSetupActivationResult(
+  result: SetupOutputResult
+): result is SetupActivationResult {
+  return "setup" in result;
+}
+
+export function formatSetupOutputResult(
+  result: SetupOutputResult,
+  options: { json: boolean }
+): string {
+  if (options.json) {
+    return JSON.stringify(result, null, 2);
+  }
+  if (!isSetupActivationResult(result)) {
+    return formatSetupResult(result, options);
+  }
+  const setupOutput = formatSetupResult(result.setup, options);
+  const connectorOutput = result.connectors.map(
+    (connector) =>
+      `connector=${connector.connectorId} installation=${connector.installation} verification=${connector.verification} code=${connector.code} remediation=${connector.remediation}`
+  );
+  return [setupOutput, ...connectorOutput].join("\n");
+}