@bendyline/gezel 1.0.6 → 1.1.0

package/dist/paths.js

@@ -42,6 +42,280 @@ function assertSafeEntityId(value, label = "entity id") {
   }
 }
 
+// src/schemas/knowledge.ts
+import {
+  KnowledgeIdSchema,
+  KnowledgeVersionSchema,
+  Sha256HexSchema
+} from "@bendyline/gezk";
+import { z } from "zod";
+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,
+  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(),
+      /** 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()
+    })
+  )
+});
+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 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,
+  catalogId: KnowledgeIdSchema,
+  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(),
+  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 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({
+    type: z.literal("retrying"),
+    attempt: z.number().int(),
+    maxAttempts: z.number().int(),
+    delayMs: z.number().nonnegative(),
+    reason: z.string()
+  }),
+  z.object({
+    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) }),
+    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()
+    }),
+    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()
+    })
+  ])
+});
+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 +367,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 +499,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 +515,29 @@ 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);
+}
+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");
 }
@@ -262,6 +565,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 +577,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 = 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");
+  }
+  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 +691,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 +873,22 @@ 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_PROMPTS_DIR_NAME,
   PROJECT_SHADOW_DIR_NAME,
+  PROJECT_TABULAR_DIR_NAME,
+  TABULAR_COMPANION_SUFFIX,
   activeMachineSharedHome,
+  aiAppItemsDir,
+  aiAppReceiptFile,
+  aiAppVersionDir,
+  aiAppsRegistryFile,
+  aiAppsRoot,
   ambientDashboardLatestFile,
   ambientDashboardStateFile,
   ambientDir,
@@ -573,6 +934,11 @@ export {
   keurmeesterDigestStatePath,
   keurmeesterDigestsDir,
   keurmeesterDir,
+  knowledgeCatalogVersionDir,
+  knowledgeCatalogsDir,
+  knowledgeDir,
+  knowledgeDownloadsDir,
+  knowledgeRegistryFile,
   machineSharedGezelDir,
   machineSharedHome,
   machineSharedMarkerFile,
@@ -581,6 +947,7 @@ export {
   meesterStatusFile,
   meesterStatusStateFile,
   pendingGrantsFile,
+  pendingHandoffsFile,
   playwrightBrowsersDir,
   projectActivityFile,
   projectArtifactsDir,
@@ -589,6 +956,9 @@ export {
   projectCodeReviewsFile,
   projectContentIndexDbFile,
   projectCreateTransactionsRoot,
+  projectDiffpackDir,
+  projectDiffpacksDir,
+  projectDiffpacksFile,
   projectDir,
   projectDocsDir,
   projectFindingLifecycleFile,
@@ -613,6 +983,8 @@ export {
   projectMemoryIndexDir,
   projectMetaFile,
   projectPrivateDir,
+  projectPromptDraftDir,
+  projectPromptsDir,
   projectQuestionsFile,
   projectReportActionsFile,
   projectScriptFile,
@@ -622,6 +994,7 @@ export {
   projectShadowDir,
   projectStorageDir,
   projectStorageScope,
+  projectTabularDir,
   projectTaskAboutFile,
   projectTaskDir,
   projectTaskFile,
@@ -634,6 +1007,7 @@ export {
   projectToolsetsInstallDir,
   projectTypeDir,
   projectTypeManifestFile,
+  projectTypeOverlayFile,
   projectTypeShardPrefix,
   projectTypeVersionDir,
   projectTypeVersionManifestFile,