@bendyline/gezel 1.0.7 → 1.1.0

package/dist/paths.js

@@ -43,158 +43,53 @@ function assertSafeEntityId(value, label = "entity id") {
 }
 
 // src/schemas/knowledge.ts
+import {
+  KnowledgeIdSchema,
+  KnowledgeVersionSchema,
+  Sha256HexSchema
+} from "@bendyline/gezk";
 import { z } from "zod";
-var KNOWLEDGE_ID_PATTERN = /^[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?$/;
-var KnowledgeIdSchema = z.string().regex(KNOWLEDGE_ID_PATTERN);
-var KNOWLEDGE_VERSION_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._+-]{0,126}[A-Za-z0-9])?$/;
-var KnowledgeVersionSchema = z.string().min(1).max(128).regex(KNOWLEDGE_VERSION_PATTERN, "catalog version must be one portable path segment").refine(
-  (value) => !/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(value),
-  "catalog version must not use a reserved Windows device name"
-);
-var KnowledgeDocumentIdSchema = z.string().min(1).max(256).refine((s) => s === s.normalize("NFC"), "document id must be NFC-normalized").refine((s) => !/[\u0000-\u001f\u007f-\u009f]/u.test(s), "document id must not contain controls").refine((s) => s === s.trim(), "document id must not have leading/trailing whitespace");
-var KnowledgeChunkUidSchema = z.string().regex(/^[0-9a-f]{32}$/);
-var Sha256HexSchema = z.string().regex(/^[0-9a-f]{64}$/);
-var KnowledgeVectorEncodingSchema = z.enum(["bit384+int8"]);
-var KnowledgeEmbeddingProfileSchema = z.object({
-  /** e.g. `gezel-multilingual-e5-small@1`. New encoding/model = new id. */
-  id: z.string().min(1),
-  model: z.object({
-    repo: z.string().min(1),
-    revision: z.string().min(1),
-    onnxDigest: z.string().optional()
-  }),
-  tokenizer: z.object({
-    kind: z.string().min(1),
-    digest: z.string().optional()
-  }),
-  pooling: z.literal("mean"),
-  normalized: z.literal(true),
-  dimensions: z.number().int().positive(),
-  maxTokens: z.number().int().positive(),
-  queryInstruction: z.string(),
-  passageInstruction: z.string(),
-  vectorEncoding: KnowledgeVectorEncodingSchema,
-  distance: z.object({
-    stage1: z.literal("hamming"),
-    stage2: z.literal("cosine")
-  }),
-  quantization: z.object({
-    int8: z.object({
-      method: z.literal("symmetric-linear"),
-      scale: z.literal(127)
-    }),
-    binary: z.object({
-      method: z.literal("sign"),
-      threshold: z.literal(0),
-      packing: z.literal("lsb-first")
-    })
-  })
-});
-var KnowledgeChunkingProfileSchema = z.object({
-  /** `gezel-markdown-chunks@2` for knowledge; `@1` names the project chunker. */
-  id: z.string().min(1),
-  unit: z.literal("tokens"),
-  tokenizer: z.literal("profile"),
-  targetTokens: z.number().int().positive(),
-  overlapTokens: z.number().int().nonnegative(),
-  contextHeader: z.object({ maxTokens: z.number().int().nonnegative() })
-});
-var KnowledgeManifestFileSchema = z.object({
-  path: z.string().min(1),
-  sizeBytes: z.number().int().nonnegative(),
-  sha256: Sha256HexSchema
-});
-var KnowledgeCatalogManifestSchema = z.object({
-  kind: z.literal("gezel-knowledge-catalog"),
-  formatVersion: z.literal(1),
-  indexSchemaVersion: z.literal(1),
-  id: KnowledgeIdSchema,
-  version: KnowledgeVersionSchema,
-  name: z.string().min(1),
-  description: z.string().optional(),
-  language: z.string().min(2),
-  publisher: z.object({
-    id: KnowledgeIdSchema,
-    name: z.string().min(1),
-    url: z.string().optional()
-  }),
-  createdAt: z.string(),
-  sourceSnapshot: z.object({
-    name: z.string(),
-    date: z.string(),
-    taxonomyVersion: z.string().optional()
-  }).optional(),
-  license: z.object({
-    name: z.string().min(1),
-    noticePath: z.string().optional(),
-    attributionRequired: z.boolean()
-  }),
-  embedding: KnowledgeEmbeddingProfileSchema,
-  chunking: KnowledgeChunkingProfileSchema,
-  topics: z.array(z.object({ id: KnowledgeIdSchema, name: z.string().min(1) })).min(1, "a catalog must ship a table of contents (at least one topic)"),
-  router: z.object({
-    shardTargetChunks: z.number().int().positive(),
-    shards: z.array(
-      z.object({
-        id: z.number().int().nonnegative(),
-        path: z.string().min(1),
-        chunks: z.number().int().nonnegative(),
-        documents: z.number().int().nonnegative(),
-        centroids: z.number().int().nonnegative(),
-        sha256: Sha256HexSchema
-      })
-    ),
-    totalCentroids: z.number().int().nonnegative()
-  }),
-  counts: z.object({
-    documents: z.number().int().nonnegative(),
-    chunks: z.number().int().nonnegative(),
-    shards: z.number().int().positive()
-  }),
-  files: z.array(KnowledgeManifestFileSchema).min(1),
-  compatibility: z.object({
-    minimumGezelVersion: z.string().optional(),
-    maximumIndexSchemaVersion: z.number().int().positive()
-  }),
-  smokeQueries: z.array(
-    z.object({
-      query: z.string().min(1),
-      expectedDocumentIds: z.array(KnowledgeDocumentIdSchema).min(1)
-    })
-  ).optional(),
-  toolchain: z.object({
-    compiler: z.string(),
-    node: z.string(),
-    sqlite: z.string().optional(),
-    sqliteVec: z.string().optional(),
-    onnxruntime: z.string().optional(),
-    platform: z.string(),
-    modelDigest: z.string().optional(),
-    tokenizerDigest: z.string().optional()
-  }).optional(),
-  signature: z.object({
-    algorithm: z.literal("ed25519"),
-    keyId: z.string().min(1),
-    canonicalization: z.literal("rfc8785"),
-    value: z.string().min(1)
-  }).optional()
-});
-var CatalogDocumentSchema = z.object({
-  id: KnowledgeDocumentIdSchema,
-  title: z.string().min(1),
-  slug: z.string().min(1),
-  summary: z.string().optional(),
-  language: z.string().min(2),
-  /** Root→leaf topic id path; the first segment must exist in the manifest. */
-  topicPath: z.array(KnowledgeIdSchema).min(1),
-  markdown: z.string(),
-  sourceUrl: z.string().optional(),
-  sourceRevision: z.string().optional(),
-  sourceUpdatedAt: z.string().optional(),
-  attribution: z.record(z.string(), z.string()).optional(),
-  aliases: z.array(z.string()).optional()
-});
+import {
+  ArtifactDigestSchema,
+  CatalogDocumentSchema,
+  DEFAULT_EMBEDDING_ONNX_FILE,
+  DEFAULT_EMBEDDING_TOKENIZER_FILE,
+  GEZK_APPLICATION_ID,
+  GEZK_FORMAT_VERSION,
+  GEZK_INDEX_SCHEMA_VERSION,
+  GEZK_MANIFEST_KIND,
+  GEZK_MIME_TYPE,
+  GEZK_REGISTRY_KIND,
+  KNOWLEDGE_ID_PATTERN,
+  KNOWLEDGE_VERSION_PATTERN,
+  KnowledgeCatalogManifestSchema,
+  KnowledgeChunkUidSchema,
+  KnowledgeChunkingProfileSchema,
+  KnowledgeDocumentIdSchema,
+  KnowledgeEmbeddingProfileSchema,
+  KnowledgeIdSchema as KnowledgeIdSchema2,
+  KnowledgeManifestFileSchema,
+  KnowledgeRegistryEntrySchema as KnowledgeRegistryEntrySchema2,
+  KnowledgeRegistryIndexSchema,
+  KnowledgeSignatureSchema,
+  KnowledgeVectorEncodingSchema,
+  KnowledgeVersionSchema as KnowledgeVersionSchema2,
+  LICENSE_NOTICE_PATH,
+  MANIFEST_PATH,
+  MIMETYPE_PATH,
+  README_PATH,
+  ROUTER_DB_PATH,
+  RepoRelativePathSchema,
+  SOURCE_NOTICES_PATH,
+  Sha256HexSchema as Sha256HexSchema2,
+  SourceNoticesSchema,
+  embeddingProfileArtifacts,
+  formatKnowledgeUri,
+  parseKnowledgeUri,
+  sameVectorSpace
+} from "@bendyline/gezk";
 var KnowledgeStorageScopeSchema = z.enum(["machine-shared", "user"]);
+var KnowledgeInstallSourceKindSchema = z.enum(["gilde", "file", "url"]);
 var KnowledgeCatalogRefSchema = z.object({
   publisherId: KnowledgeIdSchema,
   catalogId: KnowledgeIdSchema,
@@ -210,6 +105,8 @@ var KnowledgeUserRegistrySchema = z.object({
       enabled: z.boolean(),
       addedAt: z.string(),
       autoUpdate: z.boolean().optional(),
+      /** Where the install came from; entries written before it was recorded carry none. */
+      source: KnowledgeInstallSourceKindSchema.optional(),
       /** Set when the manager quarantined this catalog (with the reason). */
       disabledReason: z.string().optional()
     })
@@ -242,38 +139,11 @@ var ProjectKnowledgeCatalogsSchema = z.object({
    */
   refs: z.array(z.object({ publisherId: KnowledgeIdSchema, catalogId: KnowledgeIdSchema })).optional()
 });
-var KnowledgeRegistryEntrySchema = z.object({
-  catalogId: KnowledgeIdSchema,
-  version: z.string().min(1),
-  name: z.string().min(1),
-  description: z.string().optional(),
-  language: z.string().min(2),
-  documents: z.number().int().nonnegative(),
-  /** Size of the `.gezk` archive itself (download accounting/preflight). */
-  archiveBytes: z.number().int().nonnegative(),
-  /** sha256 of the `.gezk` archive — the ref's contentDigest after install. */
-  contentDigest: z.string().regex(/^[0-9a-f]{64}$/),
-  /** Absolute download URL. Uploaded before the registry that names it. */
-  url: z.string().url(),
-  license: z.object({ name: z.string().min(1), attributionRequired: z.boolean() }),
-  sourceSnapshot: z.object({ name: z.string(), date: z.string(), taxonomyVersion: z.string().optional() }).optional()
-});
-var KnowledgeRegistryIndexSchema = z.object({
-  kind: z.literal("gezel-knowledge-registry"),
-  formatVersion: z.literal(1),
-  publisher: z.object({
-    id: KnowledgeIdSchema,
-    name: z.string().min(1),
-    url: z.string().optional()
-  }),
-  generatedAt: z.string(),
-  catalogs: z.array(KnowledgeRegistryEntrySchema),
-  signature: z.object({
-    algorithm: z.literal("ed25519"),
-    keyId: z.string().min(1),
-    canonicalization: z.literal("rfc8785"),
-    value: z.string().min(1)
-  }).optional()
+var KnowledgeHuggingfaceFileSchema = z.object({
+  repo: z.string(),
+  /** A 40-hex commit sha, so the pinned URL is immutable. */
+  revision: z.string(),
+  path: z.string()
 });
 var KnowledgeUpdateCandidateSchema = z.object({
   publisherId: KnowledgeIdSchema,
@@ -281,24 +151,140 @@ var KnowledgeUpdateCandidateSchema = z.object({
   name: z.string(),
   installedVersion: z.string(),
   availableVersion: z.string(),
+  releasedAt: z.string(),
+  archiveBytes: z.number().int().nonnegative(),
+  contentDigest: Sha256HexSchema,
+  huggingface: KnowledgeHuggingfaceFileSchema
+});
+var KnowledgeUpdatesResponseSchema = z.object({
+  source: z.literal("gilde"),
+  checkedAt: z.string(),
+  updates: z.array(KnowledgeUpdateCandidateSchema)
+});
+var KnowledgeSemanticSearchModeSchema = z.enum(["shared", "profile", "keyword-only"]);
+var KnowledgeCatalogStatusSchema = z.object({
+  ref: KnowledgeCatalogRefSchema,
+  enabled: z.boolean(),
+  addedAt: z.string(),
+  disabledReason: z.string().optional(),
+  mounted: z.boolean(),
+  name: z.string().optional(),
+  description: z.string().optional(),
+  language: z.string().optional(),
+  license: z.string().optional(),
+  documents: z.number().int().nonnegative().optional(),
+  chunks: z.number().int().nonnegative().optional(),
+  sizeBytes: z.number().int().nonnegative().optional(),
+  /** False only for `keyword-only` catalogs (an unregistered embedding profile). */
+  vectorCompatible: z.boolean().optional(),
+  /**
+   * `shared` — queries reuse the daemon's own embedder; `profile` — the
+   * catalog's model is loaded to embed queries; `keyword-only` — no model
+   * gezel can run matches the profile, so only full-text search applies.
+   */
+  semanticSearch: KnowledgeSemanticSearchModeSchema.optional(),
+  source: KnowledgeInstallSourceKindSchema,
+  /** A strictly newer version exists in the shipped catalog content. */
+  updateAvailable: z.boolean(),
+  availableVersion: z.string().optional()
+});
+var KnowledgeAvailableCatalogSchema = z.object({
+  id: KnowledgeIdSchema,
+  publisherId: KnowledgeIdSchema,
+  name: z.string(),
+  description: z.string(),
+  tags: z.array(z.string()),
+  language: z.string(),
+  category: z.string().optional(),
+  license: z.string().optional(),
+  licenseUrl: z.string().optional(),
+  version: z.string(),
+  releasedAt: z.string(),
+  formatVersion: z.string(),
+  huggingface: KnowledgeHuggingfaceFileSchema,
+  upstream: z.string().optional(),
+  parquet: z.object({ repo: z.string(), revision: z.string(), dir: z.string() }).optional(),
+  sha256: Sha256HexSchema,
   archiveBytes: z.number().int().nonnegative(),
-  contentDigest: z.string().regex(/^[0-9a-f]{64}$/),
-  url: z.string().url()
+  uncompressedBytes: z.number().int().nonnegative(),
+  documents: z.number().int().nonnegative(),
+  chunks: z.number().int().nonnegative(),
+  embeddingProfile: z.object({ id: z.string(), modelRepo: z.string() }),
+  topics: z.array(z.object({ id: z.string(), name: z.string() })),
+  minGezelVersion: z.string().optional(),
+  /** Present when this user's registry holds a version of the catalog. */
+  installed: z.object({
+    version: z.string(),
+    contentDigest: Sha256HexSchema,
+    storageScope: KnowledgeStorageScopeSchema,
+    enabled: z.boolean(),
+    updateAvailable: z.boolean()
+  }).optional(),
+  /** The pinned bytes already sit in the machine-shared asset store. */
+  sharedOnDevice: z.boolean(),
+  installing: z.boolean(),
+  /** A resumable partial download of the pinned archive exists. */
+  incompleteDownload: z.boolean()
 });
-var KnowledgeUpdatesResponseSchema = z.discriminatedUnion("available", [
+var KnowledgeInstallPhaseSchema = z.enum(["download", "extract", "embedder"]);
+var KnowledgeInstallEventSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("progress"),
+    phase: KnowledgeInstallPhaseSchema,
+    bytesDone: z.number().nonnegative(),
+    bytesTotal: z.number().nonnegative()
+  }),
+  z.object({ type: z.literal("verifying") }),
   z.object({
-    available: z.literal(false),
-    reason: z.enum(["no-registry-url", "network-blocked", "no-trust-anchors", "fetch-failed"]),
-    detail: z.string().optional()
+    type: z.literal("retrying"),
+    attempt: z.number().int(),
+    maxAttempts: z.number().int(),
+    delayMs: z.number().nonnegative(),
+    reason: z.string()
   }),
   z.object({
-    available: z.literal(true),
-    registryUrl: z.string(),
-    publisher: z.object({ id: KnowledgeIdSchema, name: z.string() }),
-    checkedAt: z.string(),
-    updates: z.array(KnowledgeUpdateCandidateSchema)
+    type: z.literal("done"),
+    ref: KnowledgeCatalogRefSchema,
+    rootDir: z.string(),
+    storageScope: KnowledgeStorageScopeSchema,
+    /** Installed and mounted, but an optional step (the query embedder) did not complete. */
+    warning: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("error"),
+    error: z.string(),
+    /** Set when the downloaded bytes did not match the pinned digest. */
+    mismatch: z.object({ expected: Sha256HexSchema, actual: Sha256HexSchema }).optional()
   })
 ]);
+var KnowledgeInstallJobSchema = z.object({
+  id: z.string(),
+  startedAt: z.string(),
+  finished: z.boolean(),
+  error: z.string().optional(),
+  /** The latest progress event and, once finished, the terminal event. */
+  events: z.array(KnowledgeInstallEventSchema)
+});
+var KnowledgeActiveInstallSchema = z.object({
+  jobId: z.string(),
+  /** Known up front for catalog installs; a file/URL install learns it at `done`. */
+  catalogId: KnowledgeIdSchema.optional(),
+  startedAt: z.string(),
+  phase: z.enum(["download", "verifying", "extract", "embedder", "retrying"]),
+  bytesDone: z.number().nonnegative(),
+  bytesTotal: z.number().nonnegative()
+});
+var IncompleteKnowledgeDownloadSchema = z.object({
+  /** The temp-file stem: the pinned sha256's first 16 hex chars, or a hash of the URL. */
+  key: z.string().regex(/^[0-9a-f]{16}$/),
+  bytes: z.number().int().nonnegative(),
+  updatedAt: z.string(),
+  /** True when the key still matches a catalog entry, so a re-install resumes it. */
+  resumable: z.boolean(),
+  catalogId: KnowledgeIdSchema.optional(),
+  name: z.string().optional(),
+  archiveBytes: z.number().int().nonnegative().optional()
+});
 var KnowledgeInstallRequestSchema = z.object({
   source: z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("file"), path: z.string().min(1) }),
@@ -308,6 +294,14 @@ var KnowledgeInstallRequestSchema = z.object({
       /** Optional out-of-band identity for remote imports. When present, the
        * daemon rejects bytes that do not match before extracting the archive. */
       expectedSha256: z.string().regex(/^[0-9a-fA-F]{64}$/).optional()
+    }),
+    z.object({
+      kind: z.literal("catalog"),
+      /** A gilde `knowledge-catalog` id; its pinned sha256 + commit are the trust root. */
+      id: KnowledgeIdSchema,
+      version: z.string().optional(),
+      /** `auto` (default) prefers the machine-shared store when a machine engine is adopted. */
+      placement: z.enum(["auto", "user"]).optional()
     })
   ])
 });
@@ -537,6 +531,13 @@ function projectDiffpacksDir(root, projectId, external) {
 function projectDiffpackDir(root, projectId, packId, external) {
   return join(projectDiffpacksDir(root, projectId, external), packId);
 }
+var PROJECT_PROMPTS_DIR_NAME = "prompts";
+function projectPromptsDir(root, projectId, external) {
+  return join(projectArtifactsDir(root, projectId, external), PROJECT_PROMPTS_DIR_NAME);
+}
+function projectPromptDraftDir(root, projectId, draftId, external) {
+  return join(projectPromptsDir(root, projectId, external), draftId);
+}
 function projectMemoriesDir(root, projectId, external) {
   return join(projectDir(root, projectId, external), "memories");
 }
@@ -586,9 +587,9 @@ function knowledgeCatalogsDir(root) {
   return join(knowledgeDir(root), "catalogs");
 }
 function knowledgeCatalogVersionDir(root, publisherId, catalogId, version, contentDigest) {
-  const publisher = KnowledgeIdSchema.parse(publisherId);
-  const catalog = KnowledgeIdSchema.parse(catalogId);
-  const catalogVersion = KnowledgeVersionSchema.parse(version);
+  const publisher = KnowledgeIdSchema2.parse(publisherId);
+  const catalog = KnowledgeIdSchema2.parse(catalogId);
+  const catalogVersion = KnowledgeVersionSchema2.parse(version);
   if (!/^[0-9a-f]{64}$/i.test(contentDigest)) {
     throw new Error("knowledge catalog content digest must be a sha256");
   }
@@ -878,6 +879,7 @@ export {
   OBSERVATION_TABLE_MANIFEST_FILE,
   OBSERVATION_TABLE_STATE_FILE,
   PROJECT_DIFFPACKS_DIR_NAME,
+  PROJECT_PROMPTS_DIR_NAME,
   PROJECT_SHADOW_DIR_NAME,
   PROJECT_TABULAR_DIR_NAME,
   TABULAR_COMPANION_SUFFIX,
@@ -981,6 +983,8 @@ export {
   projectMemoryIndexDir,
   projectMetaFile,
   projectPrivateDir,
+  projectPromptDraftDir,
+  projectPromptsDir,
   projectQuestionsFile,
   projectReportActionsFile,
   projectScriptFile,