@gmickel/gno 1.21.0 → 1.23.0

package/spec/output-schemas/publish-artifact.schema.json

@@ -0,0 +1,284 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "gno://schemas/publish-artifact@1.0",
+  "title": "GNO publish artifact",
+  "oneOf": [
+    { "$ref": "#/definitions/artifactV1" },
+    { "$ref": "#/definitions/artifactV2" }
+  ],
+  "definitions": {
+    "artifactV1": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["version", "source", "exportedAt", "spaces"],
+      "properties": {
+        "version": { "const": 1 },
+        "source": { "$ref": "#/definitions/slug" },
+        "exportedAt": { "type": "string", "format": "date-time" },
+        "spaces": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "oneOf": [
+              { "$ref": "#/definitions/publicSpace" },
+              { "$ref": "#/definitions/restrictedSpace" }
+            ]
+          }
+        }
+      }
+    },
+    "artifactV2": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["version", "source", "exportedAt", "spaces"],
+      "properties": {
+        "version": { "const": 2 },
+        "source": { "$ref": "#/definitions/slug" },
+        "exportedAt": { "type": "string", "format": "date-time" },
+        "spaces": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/encryptedSpace" }
+        }
+      }
+    },
+    "slug": {
+      "type": "string",
+      "pattern": "^[a-z0-9](?:[a-z0-9-]{0,78}[a-z0-9])?$",
+      "maxLength": 80
+    },
+    "hash": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "docid": {
+      "type": "string",
+      "pattern": "^#[a-f0-9]{8}$"
+    },
+    "metadata": {
+      "type": "object",
+      "additionalProperties": {
+        "oneOf": [
+          { "type": "string" },
+          {
+            "type": "array",
+            "items": { "type": "string" }
+          }
+        ]
+      }
+    },
+    "note": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["markdown", "slug", "summary", "title"],
+      "properties": {
+        "markdown": { "type": "string" },
+        "metadata": { "$ref": "#/definitions/metadata" },
+        "slug": { "$ref": "#/definitions/slug" },
+        "summary": { "type": "string" },
+        "title": { "type": "string", "minLength": 1 }
+      }
+    },
+    "publicSpace": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "notes",
+        "routeSlug",
+        "sourceType",
+        "summary",
+        "title",
+        "visibility",
+        "manifest"
+      ],
+      "properties": {
+        "homeNoteSlug": { "$ref": "#/definitions/slug" },
+        "notes": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/note" }
+        },
+        "routeSlug": { "$ref": "#/definitions/slug" },
+        "sourceType": { "enum": ["note", "collection"] },
+        "summary": { "type": "string" },
+        "title": { "type": "string", "minLength": 1 },
+        "visibility": { "const": "public" },
+        "manifest": { "$ref": "#/definitions/publicManifest" }
+      }
+    },
+    "restrictedSpace": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "notes",
+        "routeSlug",
+        "sourceType",
+        "summary",
+        "title",
+        "visibility"
+      ],
+      "properties": {
+        "homeNoteSlug": { "$ref": "#/definitions/slug" },
+        "notes": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/note" }
+        },
+        "routeSlug": { "$ref": "#/definitions/slug" },
+        "sourceType": { "enum": ["note", "collection"] },
+        "summary": { "type": "string" },
+        "title": { "type": "string", "minLength": 1 },
+        "visibility": { "enum": ["secret-link", "invite-only"] }
+      }
+    },
+    "publicManifest": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "schemaVersion",
+        "projectionRevision",
+        "generatedAt",
+        "visibility",
+        "capabilities",
+        "documents"
+      ],
+      "properties": {
+        "schemaVersion": { "const": "1.0" },
+        "projectionRevision": { "$ref": "#/definitions/hash" },
+        "generatedAt": { "type": "string", "format": "date-time" },
+        "visibility": { "const": "public" },
+        "capabilities": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "capsuleEvidence",
+            "exactLineCitations",
+            "llmsTxt",
+            "markdownDocuments"
+          ],
+          "properties": {
+            "capsuleEvidence": { "const": true },
+            "exactLineCitations": { "const": true },
+            "llmsTxt": { "const": true },
+            "markdownDocuments": { "const": true }
+          }
+        },
+        "documents": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/definitions/publicDocument" }
+        }
+      }
+    },
+    "publicDocument": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "slug",
+        "title",
+        "summary",
+        "markdownPath",
+        "contentHash",
+        "byteLength",
+        "lineCount",
+        "evidence"
+      ],
+      "properties": {
+        "slug": { "$ref": "#/definitions/slug" },
+        "title": { "type": "string", "minLength": 1 },
+        "summary": { "type": "string" },
+        "markdownPath": {
+          "type": "string",
+          "pattern": "^\\./[a-z0-9](?:[a-z0-9-]{0,78}[a-z0-9])?\\.md$"
+        },
+        "contentHash": { "$ref": "#/definitions/hash" },
+        "byteLength": { "type": "integer", "minimum": 0 },
+        "lineCount": { "type": "integer", "minimum": 1 },
+        "evidence": { "$ref": "#/definitions/publicEvidence" }
+      }
+    },
+    "publicEvidence": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "evidenceId",
+        "uri",
+        "docid",
+        "startLine",
+        "endLine",
+        "sourceHash",
+        "mirrorHash",
+        "passageHash",
+        "locator"
+      ],
+      "properties": {
+        "evidenceId": { "$ref": "#/definitions/hash" },
+        "uri": {
+          "type": "string",
+          "pattern": "^gno://public/[a-z0-9][a-z0-9-]{0,79}/[a-z0-9][a-z0-9-]{0,79}\\.md$"
+        },
+        "docid": { "$ref": "#/definitions/docid" },
+        "startLine": { "const": 1 },
+        "endLine": { "type": "integer", "minimum": 1 },
+        "sourceHash": { "$ref": "#/definitions/hash" },
+        "mirrorHash": { "$ref": "#/definitions/hash" },
+        "passageHash": { "$ref": "#/definitions/hash" },
+        "locator": {
+          "type": "string",
+          "pattern": "^\\./[a-z0-9][a-z0-9-]{0,79}\\.md#L1-L[1-9][0-9]*$"
+        }
+      }
+    },
+    "encryptedSpace": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "encryptedPayload",
+        "routeSlug",
+        "secretToken",
+        "sourceType",
+        "visibility"
+      ],
+      "properties": {
+        "encryptedPayload": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["ciphertext", "iterations", "iv", "salt"],
+          "properties": {
+            "ciphertext": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 67108864,
+              "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"
+            },
+            "iterations": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 9007199254740991
+            },
+            "iv": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 1024,
+              "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"
+            },
+            "salt": {
+              "type": "string",
+              "minLength": 1,
+              "maxLength": 1024,
+              "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"
+            }
+          }
+        },
+        "routeSlug": { "$ref": "#/definitions/slug" },
+        "secretToken": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 512
+        },
+        "sourceType": { "enum": ["note", "collection"] },
+        "visibility": { "const": "encrypted" }
+      }
+    }
+  }
+}

package/spec/output-schemas/query-diagnose-v1.schema.json

@@ -0,0 +1,123 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "gno://schemas/query-diagnose@1.0",
+  "title": "GNO Query Diagnose",
+  "type": "object",
+  "required": ["schemaVersion", "query", "target", "stages", "chunk", "meta"],
+  "properties": {
+    "schemaVersion": { "type": "string", "const": "1.0" },
+    "query": { "type": "string" },
+    "target": {
+      "type": "object",
+      "required": [
+        "ref",
+        "status",
+        "docid",
+        "uri",
+        "title",
+        "contentType",
+        "contentTypeSource",
+        "categories",
+        "graphHints",
+        "contentTypeRulesFingerprint",
+        "contentTypeFingerprintMatches",
+        "mirrorHash",
+        "chunkCount",
+        "filterReasons"
+      ],
+      "properties": {
+        "ref": { "type": "string" },
+        "status": {
+          "type": "string",
+          "enum": [
+            "not_found",
+            "inactive",
+            "no_indexed_content",
+            "filtered_out",
+            "diagnosed"
+          ]
+        },
+        "docid": { "type": ["string", "null"], "pattern": "^#[a-f0-9]{6,}$" },
+        "uri": { "type": ["string", "null"], "format": "uri" },
+        "title": { "type": ["string", "null"] },
+        "contentType": { "type": ["string", "null"] },
+        "contentTypeSource": { "type": ["string", "null"] },
+        "categories": { "type": "array", "items": { "type": "string" } },
+        "graphHints": { "type": "array", "items": { "type": "string" } },
+        "contentTypeRulesFingerprint": { "type": ["string", "null"] },
+        "contentTypeFingerprintMatches": { "type": ["boolean", "null"] },
+        "mirrorHash": { "type": ["string", "null"] },
+        "chunkCount": { "type": "integer", "minimum": 0 },
+        "filterReasons": { "type": "array", "items": { "type": "string" } }
+      },
+      "additionalProperties": false
+    },
+    "stages": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "status",
+          "sourceCount",
+          "present",
+          "rank",
+          "score",
+          "survived",
+          "dropReason"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "enum": ["bm25", "vector", "fusion", "graph", "rerank"]
+          },
+          "status": { "type": "string", "enum": ["active", "skipped"] },
+          "sourceCount": { "type": "integer", "minimum": 0 },
+          "present": { "type": "boolean" },
+          "rank": { "type": ["integer", "null"], "minimum": 1 },
+          "score": { "type": ["number", "null"] },
+          "survived": { "type": "boolean" },
+          "dropReason": {
+            "type": ["string", "null"],
+            "enum": ["not_in_candidate_set", "below_cutoff", "skipped", null]
+          },
+          "reason": { "type": "string" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "chunk": {
+      "type": "object",
+      "required": ["seq", "startLine", "endLine", "language"],
+      "properties": {
+        "seq": { "type": ["integer", "null"], "minimum": 0 },
+        "startLine": { "type": ["integer", "null"], "minimum": 1 },
+        "endLine": { "type": ["integer", "null"], "minimum": 1 },
+        "language": { "type": ["string", "null"] }
+      },
+      "additionalProperties": false
+    },
+    "meta": {
+      "type": "object",
+      "required": ["mode", "vectorsUsed", "reranked", "totalResults"],
+      "properties": {
+        "mode": { "type": "string", "enum": ["bm25_only", "hybrid"] },
+        "vectorsUsed": { "type": "boolean" },
+        "reranked": { "type": "boolean" },
+        "totalResults": { "type": "integer", "minimum": 0 },
+        "queryModes": {
+          "type": "object",
+          "required": ["term", "intent", "hyde"],
+          "properties": {
+            "term": { "type": "integer", "minimum": 0 },
+            "intent": { "type": "integer", "minimum": 0 },
+            "hyde": { "type": "boolean" }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}

package/spec/output-schemas/query-diagnose.schema.json

@@ -1,11 +1,11 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "gno://schemas/query-diagnose@1.0",
+  "$id": "gno://schemas/query-diagnose@1.1",
   "title": "GNO Query Diagnose",
   "type": "object",
   "required": ["schemaVersion", "query", "target", "stages", "chunk", "meta"],
   "properties": {
-    "schemaVersion": { "type": "string", "const": "1.0" },
+    "schemaVersion": { "type": "string", "enum": ["1.0", "1.1"] },
     "query": { "type": "string" },
     "target": {
       "type": "object",
@@ -86,6 +86,74 @@
         "additionalProperties": false
       }
     },
+    "affinity": {
+      "type": "object",
+      "required": [
+        "affinityAdjustedScore",
+        "affinityApplied",
+        "affinityRequested",
+        "affinityWeight",
+        "baseScore",
+        "collectionAlias",
+        "combinedAuxiliaryApplied",
+        "combinedAuxiliaryCap",
+        "combinedAuxiliaryRequested",
+        "finalBlendedScore",
+        "finalScore",
+        "matched",
+        "rawScore",
+        "rawScoreKind",
+        "rootAlias",
+        "source"
+      ],
+      "properties": {
+        "affinityAdjustedScore": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "affinityApplied": { "type": "number" },
+        "affinityRequested": { "type": "number" },
+        "affinityWeight": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 0.03
+        },
+        "baseScore": { "type": "number", "minimum": 0, "maximum": 1 },
+        "collectionAlias": {
+          "type": ["string", "null"],
+          "pattern": "^collection_[a-f0-9]{12}$"
+        },
+        "combinedAuxiliaryApplied": {
+          "type": "number",
+          "minimum": -0.08,
+          "maximum": 0.08
+        },
+        "combinedAuxiliaryCap": { "type": "number", "const": 0.08 },
+        "combinedAuxiliaryRequested": { "type": "number" },
+        "finalBlendedScore": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 1
+        },
+        "finalScore": { "type": "number", "minimum": 0, "maximum": 1 },
+        "matched": { "type": "boolean" },
+        "rawScore": { "type": "number" },
+        "rawScoreKind": {
+          "type": "string",
+          "enum": ["bm25", "hybrid_blended", "normalized", "vector_distance"]
+        },
+        "rootAlias": {
+          "type": ["string", "null"],
+          "pattern": "^root_[a-f0-9]{12}$"
+        },
+        "source": {
+          "type": ["string", "null"],
+          "enum": ["cli_cwd", "cli_explicit", "cli_worktree", null]
+        }
+      },
+      "additionalProperties": false
+    },
     "chunk": {
       "type": "object",
       "required": ["seq", "startLine", "endLine", "language"],
@@ -119,5 +187,24 @@
       "additionalProperties": false
     }
   },
+  "allOf": [
+    {
+      "if": {
+        "properties": { "schemaVersion": { "const": "1.0" } },
+        "required": ["schemaVersion"]
+      },
+      "then": { "properties": { "affinity": false } }
+    },
+    {
+      "if": {
+        "properties": { "schemaVersion": { "const": "1.1" } },
+        "required": ["schemaVersion"]
+      },
+      "then": {
+        "properties": { "affinity": {} },
+        "required": ["affinity"]
+      }
+    }
+  ],
   "additionalProperties": false
 }

package/src/app/context-runtime-types.ts

@@ -4,6 +4,7 @@ import type { ContextEvidenceCompilerDeps } from "../core/context-evidence";
 import type { ContextVerifierDeps } from "../core/context-verifier";
 import type { RetrievalTraceSession } from "../core/retrieval-trace-session";
 import type { EmbeddingPort, RerankPort } from "../llm/types";
+import type { ProjectAffinityScoringInput } from "../pipeline/project-affinity";
 import type { QueryModeInput } from "../pipeline/types";
 import type { StorePort } from "../store/types";
 import type { VectorIndexPort } from "../store/vector";
@@ -50,6 +51,8 @@ export interface ContextCapsuleRuntimeDeps {
   countTokens?: (accountingJson: string) => number;
   tokenizerFingerprint?: string | null;
   resolveCurrentRanks?: ContextVerifierDeps["resolveCurrentRanks"];
+  /** Trusted, already-resolved project affinity; never accepts raw inputs. */
+  projectAffinity?: ProjectAffinityScoringInput;
   /** Optional non-canonical receipt session owned by the calling surface. */
   traceSession?: RetrievalTraceSession;
 }

package/src/app/context-runtime.ts

@@ -96,6 +96,7 @@ export const buildContextCapsule = async (
           {
             ...request,
             noRerank: requestNoRerank,
+            projectAffinity: deps.projectAffinity,
             traceSession: deps.traceSession,
           }
         );

package/src/app/context-surface.ts

@@ -44,6 +44,7 @@ export const contextBuildSurfaceSchema = z
     safetyMarginTokens: nonnegativeInteger.optional(),
     safetyMarginBytes: nonnegativeInteger.optional(),
     depthPolicy: z.enum(["fast", "balanced", "thorough"]).optional(),
+    projectHints: z.array(z.string()).max(16).optional(),
     format: z.enum(["json", "md"]).optional(),
   })
   .strict();
@@ -60,6 +61,7 @@ export type ContextSurfaceFormat = "json" | "md";
 export interface ParsedContextBuildSurfaceInput {
   input: ContextCapsuleBuildInput;
   format: ContextSurfaceFormat;
+  projectHints?: string[];
 }
 
 export interface ParsedContextVerifySurfaceInput {
@@ -117,8 +119,8 @@ export const parseContextBuildSurfaceInput = (
 ): ParsedContextBuildSurfaceInput => {
   const parsed = contextBuildSurfaceSchema.safeParse(value);
   if (!parsed.success) throw invalidInput(parsed.error);
-  const { format = "json", ...input } = parsed.data;
-  return { input: { ...input, indexName }, format };
+  const { format = "json", projectHints, ...input } = parsed.data;
+  return { input: { ...input, indexName }, format, projectHints };
 };
 
 export const parseContextVerifySurfaceInput = (

package/src/cli/commands/ask.ts

@@ -5,6 +5,7 @@
  * @module src/cli/commands/ask
  */
 
+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 {
@@ -15,6 +16,7 @@ import type {
 import type { AskOptions, AskResult, Citation } from "../../pipeline/types";
 
 import { buildVerifiedAsk } from "../../app/verified-ask";
+import { resolveCliProjectAffinity } from "../../core/project-affinity-surface";
 import {
   finishRetrievalTraceAfterError,
   retrievalTraceFilters,
@@ -46,24 +48,25 @@ export { formatAsk } from "./ask-format";
 // Types
 // ─────────────────────────────────────────────────────────────────────────────
 
-export type AskCommandOptions = AskOptions & {
-  /** Override config path */
-  configPath?: string;
-  /** Override embedding model */
-  embedModel?: string;
-  /** Override expansion model */
-  expandModel?: string;
-  /** Override answer generation model */
-  genModel?: string;
-  /** Override rerank model */
-  rerankModel?: string;
-  /** Output as JSON */
-  json?: boolean;
-  /** Output as Markdown */
-  md?: boolean;
-  /** Show all retrieved sources (not just cited) */
-  showSources?: boolean;
-};
+export type AskCommandOptions = Omit<AskOptions, "projectAffinity"> &
+  CliProjectAffinityRequest & {
+    /** Override config path */
+    configPath?: string;
+    /** Override embedding model */
+    embedModel?: string;
+    /** Override expansion model */
+    expandModel?: string;
+    /** Override answer generation model */
+    genModel?: string;
+    /** Override rerank model */
+    rerankModel?: string;
+    /** Output as JSON */
+    json?: boolean;
+    /** Output as Markdown */
+    md?: boolean;
+    /** Show all retrieved sources (not just cited) */
+    showSources?: boolean;
+  };
 
 export type AskCommandResult =
   | {
@@ -108,6 +111,12 @@ export async function ask(
   let traceSession: RetrievalTraceSession | undefined;
 
   try {
+    const { projectAffinityDisabled, projectRoots, ...askOptions } = options;
+    const projectAffinity = await resolveCliProjectAffinity(config, {
+      cwd: process.cwd(),
+      disabled: projectAffinityDisabled,
+      projectRoots,
+    });
     const verificationRequested = options.verify === true;
     const answerRequested =
       verificationRequested || Boolean(options.answer && !options.noAnswer);
@@ -141,7 +150,7 @@ export async function ask(
       store,
       config,
       query,
-      filters: retrievalTraceFilters({ ...options, limit }),
+      filters: retrievalTraceFilters({ ...askOptions, limit }),
       pipeline: "ask",
       indexName: globals.index,
       modelUris: [embedUri, expandUri, answerUri, rerankUri].filter(
@@ -264,7 +273,7 @@ export async function ask(
     if (verificationRequested && answerPort) {
       const verified = await buildVerifiedAsk(
         query,
-        { ...options, limit },
+        { ...askOptions, limit, projectAffinity },
         {
           store,
           config,
@@ -273,6 +282,7 @@ export async function ask(
           embedPort,
           rerankPort,
           genPort: answerPort,
+          projectAffinity,
           traceSession,
         }
       );
@@ -308,6 +318,7 @@ export async function ask(
       noExpand: options.noExpand,
       noRerank: options.noRerank,
       candidateLimit: options.candidateLimit,
+      projectAffinity,
       traceSession,
     });