@bendyline/gezel 1.0.6 → 1.0.7

package/dist/paths.js

@@ -42,6 +42,286 @@ function assertSafeEntityId(value, label = "entity id") {
   }
 }
 
+// src/schemas/knowledge.ts
+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()
+});
+var KnowledgeStorageScopeSchema = z.enum(["machine-shared", "user"]);
+var KnowledgeCatalogRefSchema = z.object({
+  publisherId: KnowledgeIdSchema,
+  catalogId: KnowledgeIdSchema,
+  version: KnowledgeVersionSchema,
+  contentDigest: Sha256HexSchema,
+  storageScope: KnowledgeStorageScopeSchema
+});
+var KnowledgeUserRegistrySchema = z.object({
+  version: z.literal(1),
+  catalogs: z.array(
+    z.object({
+      ref: KnowledgeCatalogRefSchema,
+      enabled: z.boolean(),
+      addedAt: z.string(),
+      autoUpdate: z.boolean().optional(),
+      /** Set when the manager quarantined this catalog (with the reason). */
+      disabledReason: z.string().optional()
+    })
+  )
+});
+var KnowledgeMachineInventorySchema = z.object({
+  version: z.literal(1),
+  catalogs: z.array(
+    z.object({
+      publisherId: KnowledgeIdSchema,
+      catalogId: KnowledgeIdSchema,
+      version: KnowledgeVersionSchema,
+      contentDigest: Sha256HexSchema,
+      publishedAt: z.string(),
+      bytes: z.number().int().nonnegative()
+    })
+  )
+});
+var TrustedKnowledgeCoordinateSchema = z.object({
+  publisherId: KnowledgeIdSchema,
+  catalogId: KnowledgeIdSchema,
+  version: KnowledgeVersionSchema,
+  expectedDigest: Sha256HexSchema
+});
+var ProjectKnowledgeCatalogsSchema = z.object({
+  mode: z.enum(["inherit", "selected", "off"]),
+  /**
+   * Only for mode 'selected'. Unresolvable refs are RETAINED (not stripped)
+   * so a restored project regains its selection when the catalog returns.
+   */
+  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 KnowledgeUpdateCandidateSchema = z.object({
+  publisherId: KnowledgeIdSchema,
+  catalogId: KnowledgeIdSchema,
+  name: z.string(),
+  installedVersion: z.string(),
+  availableVersion: z.string(),
+  archiveBytes: z.number().int().nonnegative(),
+  contentDigest: z.string().regex(/^[0-9a-f]{64}$/),
+  url: z.string().url()
+});
+var KnowledgeUpdatesResponseSchema = z.discriminatedUnion("available", [
+  z.object({
+    available: z.literal(false),
+    reason: z.enum(["no-registry-url", "network-blocked", "no-trust-anchors", "fetch-failed"]),
+    detail: z.string().optional()
+  }),
+  z.object({
+    available: z.literal(true),
+    registryUrl: z.string(),
+    publisher: z.object({ id: KnowledgeIdSchema, name: z.string() }),
+    checkedAt: z.string(),
+    updates: z.array(KnowledgeUpdateCandidateSchema)
+  })
+]);
+var KnowledgeInstallRequestSchema = z.object({
+  source: z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("file"), path: z.string().min(1) }),
+    z.object({
+      kind: z.literal("url"),
+      url: z.string().url(),
+      /** 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()
+    })
+  ])
+});
+var UpdateKnowledgeCatalogRequestSchema = z.object({
+  enabled: z.boolean().optional(),
+  autoUpdate: z.boolean().optional()
+});
+var KnowledgeSearchRequestSchema = z.object({
+  query: z.string().min(1),
+  maxResults: z.number().int().min(1).max(50).optional(),
+  /** Restrict to these catalog ids (default: every enabled catalog). */
+  catalogs: z.array(KnowledgeIdSchema).optional()
+});
+
 // src/paths.ts
 var MACHINE_SHARED_MARKER = ".gezel-machine-shared-v1.json";
 function machineSharedHome(platform = process.platform, env = process.env) {
@@ -93,6 +373,9 @@ function userProjectDir(root, projectId) {
 function projectPrivateDir(root, projectId) {
   return userProjectDir(root, projectId);
 }
+function projectTypeOverlayFile(root, projectId) {
+  return join(projectPrivateDir(root, projectId), "project-type-overlay.json");
+}
 function machineSharedGezelDir(gezelId) {
   assertSafeEntityId(gezelId, "gezel id");
   const shared = activeMachineSharedHome();
@@ -222,6 +505,9 @@ function projectBoekwachterIssuesFile(root, projectId) {
 function projectCodeReviewsFile(root, projectId) {
   return join(projectPrivateDir(root, projectId), "code-reviews.json");
 }
+function projectDiffpacksFile(root, projectId) {
+  return join(projectPrivateDir(root, projectId), "diffpacks.json");
+}
 function projectReportActionsFile(root, projectId) {
   return join(projectPrivateDir(root, projectId), "report-actions.json");
 }
@@ -235,6 +521,22 @@ var PROJECT_SHADOW_DIR_NAME = "shadow";
 function projectShadowDir(root, projectId, external) {
   return join(projectArtifactsDir(root, projectId, external), PROJECT_SHADOW_DIR_NAME);
 }
+var PROJECT_TABULAR_DIR_NAME = "tabular";
+var TABULAR_COMPANION_SUFFIX = "_tables";
+function projectTabularDir(root, projectId, external) {
+  return join(projectArtifactsDir(root, projectId, external), PROJECT_TABULAR_DIR_NAME);
+}
+var CONNECTOR_TABLES_DIR_NAME = "tables";
+var CONNECTOR_ROLLUPS_DIR_NAME = "rollups";
+var OBSERVATION_TABLE_MANIFEST_FILE = "manifest.json";
+var OBSERVATION_TABLE_STATE_FILE = "state.json";
+var PROJECT_DIFFPACKS_DIR_NAME = "diffpacks";
+function projectDiffpacksDir(root, projectId, external) {
+  return join(projectArtifactsDir(root, projectId, external), PROJECT_DIFFPACKS_DIR_NAME);
+}
+function projectDiffpackDir(root, projectId, packId, external) {
+  return join(projectDiffpacksDir(root, projectId, external), packId);
+}
 function projectMemoriesDir(root, projectId, external) {
   return join(projectDir(root, projectId, external), "memories");
 }
@@ -262,6 +564,9 @@ function projectTerminalFile(root, projectId, threadId) {
 function globalHistoryFile(root) {
   return join(root, "history.jsonl");
 }
+function pendingHandoffsFile(root) {
+  return join(root, "pending-handoffs.json");
+}
 function globalIndexDir(root) {
   return join(root, "index");
 }
@@ -271,6 +576,33 @@ function globalIndexDbFile(root) {
 function projectHistoryFile(root, projectId) {
   return join(projectPrivateDir(root, projectId), "history.jsonl");
 }
+function knowledgeDir(root) {
+  return join(root, "knowledge");
+}
+function knowledgeRegistryFile(root) {
+  return join(knowledgeDir(root), "registry.json");
+}
+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);
+  if (!/^[0-9a-f]{64}$/i.test(contentDigest)) {
+    throw new Error("knowledge catalog content digest must be a sha256");
+  }
+  return join(
+    knowledgeCatalogsDir(root),
+    publisher,
+    catalog,
+    catalogVersion,
+    contentDigest.slice(0, 16)
+  );
+}
+function knowledgeDownloadsDir(root) {
+  return join(knowledgeDir(root), "downloads");
+}
 function projectQuestionsFile(root, projectId) {
   return join(projectPrivateDir(root, projectId), "questions.json");
 }
@@ -358,6 +690,21 @@ function craftbookTemplateScriptFile(root, prefix, id, version, name) {
 function craftbookShardPrefix(id) {
   return id.slice(0, 2).toLowerCase();
 }
+function aiAppsRoot(root) {
+  return join(root, "ai-apps");
+}
+function aiAppsRegistryFile(root) {
+  return join(aiAppsRoot(root), "registry.json");
+}
+function aiAppVersionDir(root, appId, version) {
+  return join(aiAppsRoot(root), appId, version);
+}
+function aiAppItemsDir(root, appId, version) {
+  return join(aiAppVersionDir(root, appId, version), "items");
+}
+function aiAppReceiptFile(root, appId, version) {
+  return join(aiAppVersionDir(root, appId, version), "receipt.json");
+}
 function projectTypesRoot(root) {
   return join(root, "project-types");
 }
@@ -525,9 +872,21 @@ async function readConfigRaw(root) {
   }
 }
 export {
+  CONNECTOR_ROLLUPS_DIR_NAME,
+  CONNECTOR_TABLES_DIR_NAME,
   MACHINE_SHARED_MARKER,
+  OBSERVATION_TABLE_MANIFEST_FILE,
+  OBSERVATION_TABLE_STATE_FILE,
+  PROJECT_DIFFPACKS_DIR_NAME,
   PROJECT_SHADOW_DIR_NAME,
+  PROJECT_TABULAR_DIR_NAME,
+  TABULAR_COMPANION_SUFFIX,
   activeMachineSharedHome,
+  aiAppItemsDir,
+  aiAppReceiptFile,
+  aiAppVersionDir,
+  aiAppsRegistryFile,
+  aiAppsRoot,
   ambientDashboardLatestFile,
   ambientDashboardStateFile,
   ambientDir,
@@ -573,6 +932,11 @@ export {
   keurmeesterDigestStatePath,
   keurmeesterDigestsDir,
   keurmeesterDir,
+  knowledgeCatalogVersionDir,
+  knowledgeCatalogsDir,
+  knowledgeDir,
+  knowledgeDownloadsDir,
+  knowledgeRegistryFile,
   machineSharedGezelDir,
   machineSharedHome,
   machineSharedMarkerFile,
@@ -581,6 +945,7 @@ export {
   meesterStatusFile,
   meesterStatusStateFile,
   pendingGrantsFile,
+  pendingHandoffsFile,
   playwrightBrowsersDir,
   projectActivityFile,
   projectArtifactsDir,
@@ -589,6 +954,9 @@ export {
   projectCodeReviewsFile,
   projectContentIndexDbFile,
   projectCreateTransactionsRoot,
+  projectDiffpackDir,
+  projectDiffpacksDir,
+  projectDiffpacksFile,
   projectDir,
   projectDocsDir,
   projectFindingLifecycleFile,
@@ -622,6 +990,7 @@ export {
   projectShadowDir,
   projectStorageDir,
   projectStorageScope,
+  projectTabularDir,
   projectTaskAboutFile,
   projectTaskDir,
   projectTaskFile,
@@ -634,6 +1003,7 @@ export {
   projectToolsetsInstallDir,
   projectTypeDir,
   projectTypeManifestFile,
+  projectTypeOverlayFile,
   projectTypeShardPrefix,
   projectTypeVersionDir,
   projectTypeVersionManifestFile,