@treeseed/sdk 0.12.62 → 0.13.0-rc.2

package/dist/treedx/support/client.js

@@ -0,0 +1,252 @@
+import * as extractedMethods from "../client/methods.js";
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/u, "");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAbortError(error) {
+  return error instanceof DOMException && error.name === "AbortError" || error instanceof Error && error.name === "AbortError";
+}
+function stripOk(payload) {
+  if (!isRecord(payload)) {
+    return payload;
+  }
+  const { ok: _ok, ...rest } = payload;
+  return rest;
+}
+function firstPayload(payload, keys) {
+  if (isRecord(payload)) {
+    for (const key of keys) {
+      if (key in payload) {
+        return payload[key];
+      }
+    }
+  }
+  return stripOk(payload);
+}
+const TREEDX_CLIENT_OPERATION_MAP = {
+  health: "getHealth",
+  ready: "getReadiness",
+  deepHealth: "getDeepHealth",
+  adminDeepHealth: "getAdminDeepHealth",
+  metrics: "getMetrics",
+  prometheusMetrics: "getPrometheusMetrics",
+  whoami: "getWhoami",
+  authMode: "getAuthMode",
+  effectiveScope: "getEffectiveScope",
+  listCapabilities: "listCapabilities",
+  listCapabilityGrants: "listCapabilityGrants",
+  putCapabilityGrant: "putCapabilityGrant",
+  listAuditEvents: "listAuditEvents",
+  planFederatedQuery: "planFederationQuery",
+  buildSnapshot: "buildSnapshot",
+  getSnapshot: "getSnapshot",
+  exportArtifact: "exportArtifact",
+  syncMirror: "syncMirror",
+  fetchRemote: "syncRepository",
+  push: "pushRepository",
+  promoteRef: "promoteRepositoryRef",
+  retireRef: "retireRepositoryRef",
+  discardOrphanRef: "discardOrphanRepositoryRef",
+  checkMirrorHealth: "checkMirrorHealth",
+  promoteMirror: "promoteMirror",
+  compactStorage: "compactAdminStorage",
+  backupStorage: "backupAdminStorage",
+  listStorageMigrations: "listStorageMigrations",
+  planStorageMigration: "planStorageMigration",
+  applyStorageMigration: "applyStorageMigration",
+  rollbackStorageMigration: "rollbackStorageMigration",
+  verifyStorageRestore: "verifyStorageRestore",
+  restoreStorage: "restoreStorage",
+  createMigration: "createMigration",
+  getMigration: "getMigration",
+  getNode: "getLocalNode",
+  listNodes: "listRegistryNodes",
+  getPlacement: "getRepositoryPlacement",
+  getRepository: "getRepository",
+  createWorkspace: "createWorkspace",
+  closeWorkspace: "closeWorkspace",
+  listTree: "listWorkspaceTree",
+  readFile: "readWorkspaceFile",
+  writeFile: "writeWorkspaceFile",
+  patchFile: "patchWorkspaceFile",
+  deleteFile: "deleteWorkspaceFile",
+  readBlob: "readRepositoryBlob",
+  writeBlob: "writeWorkspaceBlob",
+  deleteBlob: "deleteWorkspaceBlob",
+  downloadBlob: "downloadWorkspaceBlob",
+  uploadBlob: "uploadWorkspaceBlob",
+  createBlobUpload: "createWorkspaceBlobUpload",
+  uploadBlobPart: "uploadWorkspaceBlobPart",
+  completeBlobUpload: "completeWorkspaceBlobUpload",
+  abortBlobUpload: "abortWorkspaceBlobUpload",
+  listArtifacts: "listArtifacts",
+  getArtifact: "getArtifact",
+  deleteArtifact: "deleteArtifact",
+  cleanupArtifacts: "cleanupArtifacts",
+  search: "searchWorkspace",
+  status: "getWorkspaceStatus",
+  diff: "getWorkspaceDiff",
+  commit: "commitWorkspace",
+  exec: "execWorkspace",
+  readRepositoryFiles: "readRepositoryFile",
+  readRepositoryFile: "readRepositoryFile",
+  listRepositoryPaths: "listRepositoryPaths",
+  searchRepositoryFiles: "searchRepositoryFiles",
+  queryRepository: "queryRepository",
+  federatedSearch: "federatedSearch",
+  federatedQuery: "federatedQuery",
+  federatedContext: "federatedContextBuild",
+  federatedGraph: "federatedGraphQuery",
+  refreshGraph: "refreshRepositoryGraph",
+  getGraphRefreshJob: "getGraphRefreshJob",
+  refreshSearchIndex: "refreshSearchIndex",
+  getSearchIndexStatus: "getSearchIndexStatus",
+  compactSearchIndex: "compactSearchIndex",
+  queryGraph: "queryRepositoryGraph",
+  searchGraphFiles: "searchGraphFiles",
+  searchGraphSections: "searchGraphSections",
+  searchGraphEntities: "searchGraphEntities",
+  getGraphNode: "getGraphNode",
+  getRelated: "getRelatedGraphNodes",
+  getSubgraph: "getGraphSubgraph",
+  buildContext: "buildContext",
+  parseContextDsl: "parseContextQuery"
+};
+class TreeDxClient {
+  constructor(options) {
+    this.options = options;
+    this.baseUrl = normalizeBaseUrl(options.baseUrl);
+    this.token = options.token;
+    this.defaultRepoId = options.repoId;
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  options;
+  baseUrl;
+  token;
+  defaultRepoId;
+  fetchImpl;
+}
+TreeDxClient.prototype.repoId = extractedMethods.repoIdMethod;
+TreeDxClient.prototype.query = extractedMethods.queryMethod;
+TreeDxClient.prototype.headers = extractedMethods.headersMethod;
+TreeDxClient.prototype.fetchWithTimeout = extractedMethods.fetchWithTimeoutMethod;
+TreeDxClient.prototype.request = extractedMethods.requestMethod;
+TreeDxClient.prototype.requestBinary = extractedMethods.requestBinaryMethod;
+TreeDxClient.prototype.requestBlobDownload = extractedMethods.requestBlobDownloadMethod;
+TreeDxClient.prototype.requestBlobUpload = extractedMethods.requestBlobUploadMethod;
+TreeDxClient.prototype.assertBinaryOk = extractedMethods.assertBinaryOkMethod;
+TreeDxClient.prototype.parseJsonResponse = extractedMethods.parseJsonResponseMethod;
+TreeDxClient.prototype.throwApiError = extractedMethods.throwApiErrorMethod;
+TreeDxClient.prototype.health = extractedMethods.healthMethod;
+TreeDxClient.prototype.ready = extractedMethods.readyMethod;
+TreeDxClient.prototype.deepHealth = extractedMethods.deepHealthMethod;
+TreeDxClient.prototype.metrics = extractedMethods.metricsMethod;
+TreeDxClient.prototype.prometheusMetrics = extractedMethods.prometheusMetricsMethod;
+TreeDxClient.prototype.whoami = extractedMethods.whoamiMethod;
+TreeDxClient.prototype.authMode = extractedMethods.authModeMethod;
+TreeDxClient.prototype.effectiveScope = extractedMethods.effectiveScopeMethod;
+TreeDxClient.prototype.listCapabilities = extractedMethods.listCapabilitiesMethod;
+TreeDxClient.prototype.listCapabilityGrants = extractedMethods.listCapabilityGrantsMethod;
+TreeDxClient.prototype.putCapabilityGrant = extractedMethods.putCapabilityGrantMethod;
+TreeDxClient.prototype.listAuditEvents = extractedMethods.listAuditEventsMethod;
+TreeDxClient.prototype.planFederatedQuery = extractedMethods.planFederatedQueryMethod;
+TreeDxClient.prototype.buildSnapshot = extractedMethods.buildSnapshotMethod;
+TreeDxClient.prototype.getSnapshot = extractedMethods.getSnapshotMethod;
+TreeDxClient.prototype.exportArtifact = extractedMethods.exportArtifactMethod;
+TreeDxClient.prototype.downloadArtifact = extractedMethods.downloadArtifactMethod;
+TreeDxClient.prototype.syncMirror = extractedMethods.syncMirrorMethod;
+TreeDxClient.prototype.fetchRemote = extractedMethods.fetchRemoteMethod;
+TreeDxClient.prototype.push = extractedMethods.pushMethod;
+TreeDxClient.prototype.promoteRef = extractedMethods.promoteRefMethod;
+TreeDxClient.prototype.retireRef = extractedMethods.retireRefMethod;
+TreeDxClient.prototype.discardOrphanRef = extractedMethods.discardOrphanRefMethod;
+TreeDxClient.prototype.listRepositoryRefs = extractedMethods.listRepositoryRefsMethod;
+TreeDxClient.prototype.abandonWorkspace = extractedMethods.abandonWorkspaceMethod;
+TreeDxClient.prototype.checkMirrorHealth = extractedMethods.checkMirrorHealthMethod;
+TreeDxClient.prototype.promoteMirror = extractedMethods.promoteMirrorMethod;
+TreeDxClient.prototype.compactStorage = extractedMethods.compactStorageMethod;
+TreeDxClient.prototype.backupStorage = extractedMethods.backupStorageMethod;
+TreeDxClient.prototype.listStorageMigrations = extractedMethods.listStorageMigrationsMethod;
+TreeDxClient.prototype.planStorageMigration = extractedMethods.planStorageMigrationMethod;
+TreeDxClient.prototype.applyStorageMigration = extractedMethods.applyStorageMigrationMethod;
+TreeDxClient.prototype.rollbackStorageMigration = extractedMethods.rollbackStorageMigrationMethod;
+TreeDxClient.prototype.verifyStorageRestore = extractedMethods.verifyStorageRestoreMethod;
+TreeDxClient.prototype.restoreStorage = extractedMethods.restoreStorageMethod;
+TreeDxClient.prototype.createMigration = extractedMethods.createMigrationMethod;
+TreeDxClient.prototype.getMigration = extractedMethods.getMigrationMethod;
+TreeDxClient.prototype.getNode = extractedMethods.getNodeMethod;
+TreeDxClient.prototype.listNodes = extractedMethods.listNodesMethod;
+TreeDxClient.prototype.getPlacement = extractedMethods.getPlacementMethod;
+TreeDxClient.prototype.getRepository = extractedMethods.getRepositoryMethod;
+TreeDxClient.prototype.listRepositories = extractedMethods.listRepositoriesMethod;
+TreeDxClient.prototype.registerRepository = extractedMethods.registerRepositoryMethod;
+TreeDxClient.prototype.createWorkspace = extractedMethods.createWorkspaceMethod;
+TreeDxClient.prototype.closeWorkspace = extractedMethods.closeWorkspaceMethod;
+TreeDxClient.prototype.listTree = extractedMethods.listTreeMethod;
+TreeDxClient.prototype.readFile = extractedMethods.readFileMethod;
+TreeDxClient.prototype.writeFile = extractedMethods.writeFileMethod;
+TreeDxClient.prototype.writeFiles = extractedMethods.writeFilesMethod;
+TreeDxClient.prototype.applyChangeset = extractedMethods.applyChangesetMethod;
+TreeDxClient.prototype.patchFile = extractedMethods.patchFileMethod;
+TreeDxClient.prototype.deleteFile = extractedMethods.deleteFileMethod;
+TreeDxClient.prototype.readBlob = extractedMethods.readBlobMethod;
+TreeDxClient.prototype.writeBlob = extractedMethods.writeBlobMethod;
+TreeDxClient.prototype.deleteBlob = extractedMethods.deleteBlobMethod;
+TreeDxClient.prototype.downloadBlob = extractedMethods.downloadBlobMethod;
+TreeDxClient.prototype.uploadBlob = extractedMethods.uploadBlobMethod;
+TreeDxClient.prototype.createBlobUpload = extractedMethods.createBlobUploadMethod;
+TreeDxClient.prototype.uploadBlobPart = extractedMethods.uploadBlobPartMethod;
+TreeDxClient.prototype.completeBlobUpload = extractedMethods.completeBlobUploadMethod;
+TreeDxClient.prototype.abortBlobUpload = extractedMethods.abortBlobUploadMethod;
+TreeDxClient.prototype.listArtifacts = extractedMethods.listArtifactsMethod;
+TreeDxClient.prototype.getArtifact = extractedMethods.getArtifactMethod;
+TreeDxClient.prototype.deleteArtifact = extractedMethods.deleteArtifactMethod;
+TreeDxClient.prototype.cleanupArtifacts = extractedMethods.cleanupArtifactsMethod;
+TreeDxClient.prototype.search = extractedMethods.searchMethod;
+TreeDxClient.prototype.status = extractedMethods.statusMethod;
+TreeDxClient.prototype.diff = extractedMethods.diffMethod;
+TreeDxClient.prototype.commit = extractedMethods.commitMethod;
+TreeDxClient.prototype.exec = extractedMethods.execMethod;
+TreeDxClient.prototype.readRepositoryFiles = extractedMethods.readRepositoryFilesMethod;
+TreeDxClient.prototype.readRepositoryFile = extractedMethods.readRepositoryFileMethod;
+TreeDxClient.prototype.listRepositoryPaths = extractedMethods.listRepositoryPathsMethod;
+TreeDxClient.prototype.searchRepositoryFiles = extractedMethods.searchRepositoryFilesMethod;
+TreeDxClient.prototype.queryRepository = extractedMethods.queryRepositoryMethod;
+TreeDxClient.prototype.federatedSearch = extractedMethods.federatedSearchMethod;
+TreeDxClient.prototype.federatedQuery = extractedMethods.federatedQueryMethod;
+TreeDxClient.prototype.federatedContext = extractedMethods.federatedContextMethod;
+TreeDxClient.prototype.federatedGraph = extractedMethods.federatedGraphMethod;
+TreeDxClient.prototype.refreshGraph = extractedMethods.refreshGraphMethod;
+TreeDxClient.prototype.getGraphRefreshJob = extractedMethods.getGraphRefreshJobMethod;
+TreeDxClient.prototype.refreshSearchIndex = extractedMethods.refreshSearchIndexMethod;
+TreeDxClient.prototype.getSearchIndexStatus = extractedMethods.getSearchIndexStatusMethod;
+TreeDxClient.prototype.compactSearchIndex = extractedMethods.compactSearchIndexMethod;
+TreeDxClient.prototype.queryGraph = extractedMethods.queryGraphMethod;
+TreeDxClient.prototype.searchGraphFiles = extractedMethods.searchGraphFilesMethod;
+TreeDxClient.prototype.searchGraphSections = extractedMethods.searchGraphSectionsMethod;
+TreeDxClient.prototype.searchGraphEntities = extractedMethods.searchGraphEntitiesMethod;
+TreeDxClient.prototype.getGraphNode = extractedMethods.getGraphNodeMethod;
+TreeDxClient.prototype.getRelated = extractedMethods.getRelatedMethod;
+TreeDxClient.prototype.getSubgraph = extractedMethods.getSubgraphMethod;
+TreeDxClient.prototype.buildContext = extractedMethods.buildContextMethod;
+TreeDxClient.prototype.parseContextDsl = extractedMethods.parseContextDslMethod;
+TreeDxClient.prototype.graphSearch = extractedMethods.graphSearchMethod;
+function parseFilename(contentDisposition) {
+  if (!contentDisposition) {
+    return void 0;
+  }
+  const match = /filename="([^"]+)"/u.exec(contentDisposition) ?? /filename=([^;]+)/u.exec(contentDisposition);
+  return match?.[1];
+}
+export {
+  TREEDX_CLIENT_OPERATION_MAP,
+  TreeDxClient,
+  firstPayload,
+  isAbortError,
+  isRecord,
+  normalizeBaseUrl,
+  parseFilename,
+  stripOk
+};

package/dist/treedx/support/errors.d.ts

@@ -0,0 +1,13 @@
+import type { TreeDxErrorCode } from '../types.js';
+export declare class TreeDxApiError extends Error {
+    readonly status: number;
+    readonly code: TreeDxErrorCode;
+    readonly details: Record<string, unknown>;
+    readonly payload: unknown;
+    constructor(message: string, options: {
+        status: number;
+        code?: TreeDxErrorCode;
+        details?: Record<string, unknown>;
+        payload?: unknown;
+    });
+}

package/dist/treedx/support/market-integration.d.ts

@@ -0,0 +1,27 @@
+import type { ProjectFilesystemRepositoryTopology, ProjectRepositoryTopology, TreeDxInstance, TreeDxProjectLibraryBinding } from '../../entrypoints/models/sdk-types.js';
+export declare const TREEDX_DOCKER_IMAGE: "treeseed/treedx:latest";
+export declare const TREEDX_VOLUME_MOUNT_PATH: "/data";
+export declare const TREEDX_CONTENT_PATH: "src/content";
+export declare function defaultTreeDxImageRef(tag?: string): string;
+export declare function treeDxLibraryIdForProject(input: {
+    teamSlug?: string | null;
+    projectSlug?: string | null;
+    projectId?: string | null;
+}): string;
+export declare function buildManagedTreeDxInstance(input: {
+    id: string;
+    teamId: string;
+    teamSlug?: string | null;
+    visibility?: 'private' | 'public' | string | null;
+    imageRef?: string | null;
+    baseUrl?: string | null;
+    now?: string;
+}): TreeDxInstance;
+export declare function buildProjectRepositoryTopology(input: {
+    instance: Pick<TreeDxInstance, 'id' | 'baseUrl'>;
+    binding: Pick<TreeDxProjectLibraryBinding, 'libraryId' | 'repositoryId' | 'contentPath' | 'contentRepositoryUrl' | 'contentRepositoryDefaultBranch' | 'contentRepositoryRef' | 'r2BucketName' | 'r2ManifestKey'>;
+    siteRepository: Partial<ProjectFilesystemRepositoryTopology>;
+    projectRepository?: Partial<ProjectFilesystemRepositoryTopology> | null;
+}): ProjectRepositoryTopology;
+export declare function normalizeProjectRepositoryTopology(value: unknown): ProjectRepositoryTopology;
+export declare function isTreeDxCanonicalContent(topology: ProjectRepositoryTopology | null | undefined): boolean;

package/dist/treedx/support/market-integration.js

@@ -0,0 +1,162 @@
+const TREEDX_DOCKER_IMAGE = "treeseed/treedx:latest";
+const TREEDX_VOLUME_MOUNT_PATH = "/data";
+const TREEDX_CONTENT_PATH = "src/content";
+function cleanString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function safeSlug(value, fallback = "library") {
+  return String(value ?? fallback).trim().toLowerCase().replace(/[^a-z0-9_.-]+/gu, "-").replace(/^-+|-+$/gu, "") || fallback;
+}
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function defaultTreeDxImageRef(tag = "latest") {
+  const normalizedTag = cleanString(tag) ?? "latest";
+  return normalizedTag.includes("/") || normalizedTag.includes(":") ? normalizedTag : `treeseed/treedx:${normalizedTag}`;
+}
+function treeDxLibraryIdForProject(input) {
+  return [input.teamSlug, input.projectSlug ?? input.projectId].map((part) => safeSlug(part, "project")).join("/");
+}
+function buildManagedTreeDxInstance(input) {
+  const isPublic = input.visibility === "public";
+  const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: input.id,
+    teamId: input.teamId,
+    kind: isPublic ? "managed_public_federation" : "managed_private",
+    provider: isPublic ? "public_federation" : "railway",
+    name: isPublic ? "TreeSeed public federation" : `${safeSlug(input.teamSlug ?? input.teamId, "team")} TreeDX`,
+    baseUrl: cleanString(input.baseUrl),
+    registryUrl: cleanString(input.baseUrl),
+    publicRead: isPublic,
+    primary: true,
+    status: cleanString(input.baseUrl) ? "active" : "pending",
+    imageRef: input.imageRef ?? defaultTreeDxImageRef(),
+    volumeMountPath: isPublic ? null : TREEDX_VOLUME_MOUNT_PATH,
+    metadata: {
+      hostRole: "knowledge-library",
+      contentCanonical: "treedx",
+      managedBy: "treeseed-market"
+    },
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function buildProjectRepositoryTopology(input) {
+  const siteRepository = normalizeFilesystemRepository(input.siteRepository, "site");
+  return {
+    contentRepository: {
+      accessMode: "treedx",
+      githubUrl: input.binding.contentRepositoryUrl ?? null,
+      defaultBranch: input.binding.contentRepositoryDefaultBranch ?? null,
+      ref: input.binding.contentRepositoryRef ?? null,
+      contentPath: input.binding.contentPath || TREEDX_CONTENT_PATH,
+      treeDx: {
+        instanceId: input.instance.id,
+        libraryId: input.binding.libraryId,
+        repositoryId: input.binding.repositoryId ?? null,
+        baseUrl: input.instance.baseUrl ?? null
+      },
+      remote: null,
+      r2: {
+        bucketName: input.binding.r2BucketName ?? null,
+        manifestKey: input.binding.r2ManifestKey ?? null
+      }
+    },
+    siteRepository,
+    projectRepository: input.projectRepository ? normalizeFilesystemRepository(input.projectRepository, "project") : null
+  };
+}
+function normalizeProjectRepositoryTopology(value) {
+  const record = objectValue(value);
+  const content = objectValue(record.contentRepository);
+  const treeDx = objectValue(content.treeDx);
+  const remote = content.remote ? objectValue(content.remote) : null;
+  const site = normalizeFilesystemRepository(record.siteRepository, "site");
+  const project = record.projectRepository ? normalizeFilesystemRepository(record.projectRepository, "project") : null;
+  const instanceId = cleanString(treeDx.instanceId);
+  const libraryId = cleanString(treeDx.libraryId);
+  if (!instanceId || !libraryId) {
+    throw new Error("Project repository topology contentRepository.treeDx.instanceId and libraryId are required.");
+  }
+  if (site.accessMode !== "filesystem") {
+    throw new Error("Project repository topology siteRepository must use filesystem access.");
+  }
+  return {
+    contentRepository: {
+      accessMode: "treedx",
+      githubUrl: cleanString(content.githubUrl),
+      defaultBranch: cleanString(content.defaultBranch),
+      ref: cleanString(content.ref),
+      contentPath: cleanString(content.contentPath) ?? TREEDX_CONTENT_PATH,
+      treeDx: {
+        instanceId,
+        libraryId,
+        repositoryId: cleanString(treeDx.repositoryId),
+        baseUrl: cleanString(treeDx.baseUrl)
+      },
+      remote: remote ? normalizeRemoteRepository(remote) : null,
+      r2: objectValue(content.r2)
+    },
+    siteRepository: site,
+    projectRepository: project
+  };
+}
+function normalizeRemoteRepository(record) {
+  const required = [
+    "bindingId",
+    "serviceConnectionId",
+    "capabilityBindingId",
+    "providerId",
+    "providerRepositoryId",
+    "owner",
+    "name",
+    "cloneUrl",
+    "defaultRef",
+    "publicationRef",
+    "authorityId"
+  ];
+  const values = Object.fromEntries(required.map((key) => [key, cleanString(record[key])]));
+  const missing = required.filter((key) => !values[key]);
+  if (missing.length) throw new Error(`Project remote repository binding is missing: ${missing.join(", ")}.`);
+  const version = Number(record.version ?? 1);
+  if (!Number.isInteger(version) || version < 1) throw new Error("Project remote repository binding version must be a positive integer.");
+  return {
+    ...values,
+    expectedHead: cleanString(record.expectedHead),
+    observedHead: cleanString(record.observedHead),
+    grantStatus: ["ready", "missing", "suspended", "reauthorization-required"].includes(String(record.grantStatus)) ? record.grantStatus : "missing",
+    drift: ["none", "remote-ahead", "remote-behind", "diverged", "unavailable", "unknown"].includes(String(record.drift)) ? record.drift : "unknown",
+    version
+  };
+}
+function normalizeFilesystemRepository(value, fallbackName) {
+  const record = objectValue(value);
+  return {
+    accessMode: "filesystem",
+    provider: cleanString(record.provider) ?? "github",
+    owner: cleanString(record.owner),
+    name: cleanString(record.name) ?? fallbackName,
+    url: cleanString(record.url),
+    defaultBranch: cleanString(record.defaultBranch) ?? cleanString(record.ref) ?? "staging",
+    ref: cleanString(record.ref),
+    checkoutPath: cleanString(record.checkoutPath),
+    volumePath: cleanString(record.volumePath),
+    submoduleMountPath: cleanString(record.submoduleMountPath),
+    siteSubmodulePath: cleanString(record.siteSubmodulePath)
+  };
+}
+function isTreeDxCanonicalContent(topology) {
+  return topology?.contentRepository?.accessMode === "treedx" && Boolean(topology.contentRepository.treeDx?.instanceId) && Boolean(topology.contentRepository.treeDx?.libraryId);
+}
+export {
+  TREEDX_CONTENT_PATH,
+  TREEDX_DOCKER_IMAGE,
+  TREEDX_VOLUME_MOUNT_PATH,
+  buildManagedTreeDxInstance,
+  buildProjectRepositoryTopology,
+  defaultTreeDxImageRef,
+  isTreeDxCanonicalContent,
+  normalizeProjectRepositoryTopology,
+  treeDxLibraryIdForProject
+};

package/dist/treedx/support/ports.d.ts

@@ -0,0 +1,166 @@
+import type { ContentStore } from '../../content/content-store.js';
+import type { SdkContentEntry, SdkFollowRequest, SdkGetRequest, SdkMutationRequest, SdkPickRequest, SdkSearchRequest } from '../../entrypoints/models/sdk-types.js';
+import type { TreeDxFederatedClient } from '../federation/federated-client.js';
+import type { TreeDxGraphAdapter } from '../graph/graph-adapter.js';
+import type { ContentGraphRuntime } from '../graph/graph.js';
+import type { TreeDxQueryAdapter } from '../reconciliation/query-adapter.js';
+import type { TreeDxRepositoryAdapter } from '../reconciliation/repository-adapter.js';
+import type { TreeDxArtifact, TreeDxArtifactDownload, TreeDxArtifactExportRequest, TreeDxCommitRequest, TreeDxCommitResult, TreeDxCreateWorkspaceRequest, TreeDxDeleteFileRequest, TreeDxDiff, TreeDxExecRequest, TreeDxExecResult, TreeDxFederatedContextRequest, TreeDxFederatedContextResult, TreeDxFederatedGraphRequest, TreeDxFederatedGraphResult, TreeDxFederatedQueryRequest, TreeDxFederatedQueryResult, TreeDxFederatedSearchRequest, TreeDxFederatedSearchResult, TreeDxFile, TreeDxFileMutationResult, TreeDxListTreeRequest, TreeDxPatchFileRequest, TreeDxReadFileRequest, TreeDxRepositoryPathsRequest, TreeDxRepositoryPlacement, TreeDxRepositoryQueryRequest, TreeDxRepositoryQueryResult, TreeDxRepositoryReadRequest, TreeDxRepositorySearchRequest, TreeDxSearchRequest, TreeDxSearchResult, TreeDxSnapshot, TreeDxSnapshotBuildRequest, TreeDxStatus, TreeDxTreeEntry, TreeDxWorkspace, TreeDxWorkspaceRequest, TreeDxWriteFileRequest } from '../types.js';
+import type { TreeDxWorkspaceAdapter } from '../workspaces/workspace-adapter.js';
+import type { TreeDxClient } from './client.js';
+import type { TreeDxRegistryClient } from './registry-client.js';
+export interface AuthPort {
+    whoami(): Promise<unknown>;
+    effectiveScope(input?: unknown): Promise<unknown>;
+}
+export interface RepositoryPort {
+    createWorkspace(input: TreeDxCreateWorkspaceRequest): Promise<TreeDxWorkspace>;
+    closeWorkspace(workspaceId: string): Promise<void>;
+    listTree(input: TreeDxListTreeRequest): Promise<TreeDxTreeEntry[]>;
+    readFile(input: TreeDxReadFileRequest): Promise<TreeDxFile>;
+    writeFile(input: TreeDxWriteFileRequest): Promise<TreeDxFileMutationResult>;
+    patchFile(input: TreeDxPatchFileRequest): Promise<TreeDxFileMutationResult>;
+    deleteFile(input: TreeDxDeleteFileRequest): Promise<TreeDxFileMutationResult>;
+    search(input: TreeDxSearchRequest): Promise<TreeDxSearchResult>;
+    status(input: TreeDxWorkspaceRequest): Promise<TreeDxStatus>;
+    diff(input: TreeDxWorkspaceRequest): Promise<TreeDxDiff>;
+    commit(input: TreeDxCommitRequest): Promise<TreeDxCommitResult>;
+    exec(input: TreeDxExecRequest): Promise<TreeDxExecResult>;
+}
+export interface RepositoryQueryPort {
+    read(input: TreeDxRepositoryReadRequest): Promise<TreeDxRepositoryQueryResult>;
+    paths(input: TreeDxRepositoryPathsRequest): Promise<TreeDxRepositoryQueryResult>;
+    query(input: TreeDxRepositoryQueryRequest): Promise<TreeDxRepositoryQueryResult>;
+    search(input: TreeDxRepositorySearchRequest): Promise<TreeDxRepositoryQueryResult>;
+}
+export interface GraphPort {
+    refresh(input?: unknown): Promise<unknown>;
+    searchFiles(query: string, options?: unknown): Promise<unknown>;
+    searchSections(query: string, options?: unknown): Promise<unknown>;
+    searchEntities(query: string, options?: unknown): Promise<unknown>;
+    getNode(id: string, options?: unknown): Promise<unknown>;
+    query(input: unknown): Promise<unknown>;
+    buildContext(input: unknown): Promise<unknown>;
+    parseDsl(source: string): Promise<unknown>;
+}
+export interface RegistryPort {
+    resolveRepository(repoId: string): Promise<unknown>;
+    resolveRepositories(repoIds: string[]): Promise<unknown[]>;
+}
+export interface ExecPort {
+    exec(input: TreeDxExecRequest): Promise<TreeDxExecResult>;
+}
+export interface ArtifactPort {
+    buildSnapshot(input?: TreeDxSnapshotBuildRequest): Promise<TreeDxSnapshot>;
+    exportArtifact(input?: TreeDxArtifactExportRequest): Promise<TreeDxArtifact>;
+    downloadArtifact(input?: TreeDxArtifactExportRequest): Promise<TreeDxArtifactDownload>;
+}
+export interface FederatedPort {
+    search(input: TreeDxFederatedSearchRequest): Promise<TreeDxFederatedSearchResult>;
+    query(input: TreeDxFederatedQueryRequest): Promise<TreeDxFederatedQueryResult>;
+    context(input: TreeDxFederatedContextRequest): Promise<TreeDxFederatedContextResult>;
+    graph(input: TreeDxFederatedGraphRequest): Promise<TreeDxFederatedGraphResult>;
+}
+export declare class LocalRepositoryPort {
+    readonly content: ContentStore;
+    constructor(content: ContentStore);
+    list(model: string): Promise<SdkContentEntry[]>;
+    get(input: SdkGetRequest): Promise<SdkContentEntry | null>;
+    search(input: SdkSearchRequest): Promise<SdkContentEntry[]>;
+    follow(input: SdkFollowRequest): Promise<{
+        items: SdkContentEntry[];
+        since: string;
+    }>;
+    pick(input: SdkPickRequest): Promise<import("../../index.js").SdkPickResult<SdkContentEntry>>;
+    create(input: SdkMutationRequest): Promise<{
+        item: SdkContentEntry;
+        git: import("../../repositories/git-runtime.js").GitMutationResult;
+    }>;
+    update(input: SdkMutationRequest): Promise<{
+        item: SdkContentEntry;
+        git: import("../../repositories/git-runtime.js").GitMutationResult;
+    }>;
+}
+export declare class LocalRepositoryQueryPort {
+    readonly content: ContentStore;
+    constructor(content: ContentStore);
+    search(input: SdkSearchRequest): Promise<SdkContentEntry[]>;
+    query(input: SdkSearchRequest): Promise<SdkContentEntry[]>;
+}
+export declare class LocalGraphPort implements GraphPort {
+    readonly runtime: ContentGraphRuntime;
+    constructor(runtime: ContentGraphRuntime);
+    refresh(input?: unknown): Promise<import("../types.js").SdkGraphRefreshPayload>;
+    searchFiles(query: string, options?: unknown): Promise<import("../types.js").SdkGraphSearchResult[]>;
+    searchSections(query: string, options?: unknown): Promise<import("../types.js").SdkGraphSearchResult[]>;
+    searchEntities(query: string, options?: unknown): Promise<import("../types.js").SdkGraphSearchResult[]>;
+    getNode(id: string): Promise<import("../types.js").SdkGraphNode | null>;
+    query(input: unknown): Promise<import("../types.js").SdkGraphQueryResult>;
+    buildContext(input: unknown): Promise<import("../types.js").SdkContextPack>;
+    parseDsl(source: string): Promise<import("../types.js").SdkGraphDslParseResult>;
+}
+export declare class TreeDxRepositoryPort implements RepositoryPort {
+    readonly client: TreeDxClient;
+    readonly content?: TreeDxRepositoryAdapter | undefined;
+    readonly workspace?: TreeDxWorkspaceAdapter | undefined;
+    constructor(client: TreeDxClient, content?: TreeDxRepositoryAdapter | undefined, workspace?: TreeDxWorkspaceAdapter | undefined);
+    createWorkspace(input: TreeDxCreateWorkspaceRequest): Promise<TreeDxWorkspace>;
+    closeWorkspace(workspaceId: string): Promise<void>;
+    listTree(input: TreeDxListTreeRequest): Promise<TreeDxTreeEntry[]>;
+    readFile(input: TreeDxReadFileRequest): Promise<TreeDxFile>;
+    writeFile(input: TreeDxWriteFileRequest): Promise<TreeDxFileMutationResult>;
+    patchFile(input: TreeDxPatchFileRequest): Promise<TreeDxFileMutationResult>;
+    deleteFile(input: TreeDxDeleteFileRequest): Promise<TreeDxFileMutationResult>;
+    search(input: TreeDxSearchRequest): Promise<TreeDxSearchResult>;
+    status(input: TreeDxWorkspaceRequest): Promise<TreeDxStatus>;
+    diff(input: TreeDxWorkspaceRequest): Promise<TreeDxDiff>;
+    commit(input: TreeDxCommitRequest): Promise<TreeDxCommitResult>;
+    exec(input: TreeDxExecRequest): Promise<TreeDxExecResult>;
+}
+export declare class TreeDxRepositoryQueryPort implements RepositoryQueryPort {
+    readonly client: TreeDxClient;
+    readonly adapter?: TreeDxQueryAdapter | undefined;
+    constructor(client: TreeDxClient, adapter?: TreeDxQueryAdapter | undefined);
+    read(input: TreeDxRepositoryReadRequest): Promise<TreeDxRepositoryQueryResult>;
+    paths(input: TreeDxRepositoryPathsRequest): Promise<TreeDxRepositoryQueryResult>;
+    query(input: TreeDxRepositoryQueryRequest): Promise<TreeDxRepositoryQueryResult>;
+    search(input: TreeDxRepositorySearchRequest): Promise<TreeDxRepositoryQueryResult>;
+}
+export declare class TreeDxGraphPort implements GraphPort {
+    readonly adapter: TreeDxGraphAdapter;
+    constructor(adapter: TreeDxGraphAdapter);
+    refresh(input?: unknown): Promise<import("../types.js").SdkGraphRefreshPayload>;
+    searchFiles(query: string, options?: unknown): Promise<import("../types.js").SdkGraphSearchResult[]>;
+    searchSections(query: string, options?: unknown): Promise<import("../types.js").SdkGraphSearchResult[]>;
+    searchEntities(query: string, options?: unknown): Promise<import("../types.js").SdkGraphSearchResult[]>;
+    getNode(id: string, options?: unknown): Promise<import("../types.js").SdkGraphNode | null>;
+    query(input: unknown): Promise<import("../types.js").SdkGraphQueryResult>;
+    buildContext(input: unknown): Promise<import("../types.js").SdkContextPack>;
+    parseDsl(source: string): Promise<import("../types.js").SdkGraphDslParseResult>;
+}
+export declare class TreeDxRegistryPort implements RegistryPort {
+    readonly client: TreeDxRegistryClient;
+    constructor(client: TreeDxRegistryClient);
+    resolveRepository(repoId: string): Promise<TreeDxRepositoryPlacement>;
+    resolveRepositories(repoIds: string[]): Promise<TreeDxRepositoryPlacement[]>;
+}
+export declare class TreeDxFederatedPort implements FederatedPort {
+    readonly client: TreeDxFederatedClient;
+    constructor(client: TreeDxFederatedClient);
+    search(input: TreeDxFederatedSearchRequest): Promise<TreeDxFederatedSearchResult>;
+    query(input: TreeDxFederatedQueryRequest): Promise<TreeDxFederatedQueryResult>;
+    context(input: TreeDxFederatedContextRequest): Promise<TreeDxFederatedContextResult>;
+    graph(input: TreeDxFederatedGraphRequest): Promise<TreeDxFederatedGraphResult>;
+}
+export declare class TreeDxExecPort implements ExecPort {
+    readonly client: TreeDxClient;
+    constructor(client: TreeDxClient);
+    exec(input: TreeDxExecRequest): Promise<TreeDxExecResult>;
+}
+export declare class TreeDxArtifactPort implements ArtifactPort {
+    readonly client: TreeDxClient;
+    constructor(client: TreeDxClient);
+    buildSnapshot(input?: TreeDxSnapshotBuildRequest): Promise<TreeDxSnapshot>;
+    exportArtifact(input?: TreeDxArtifactExportRequest): Promise<TreeDxArtifact>;
+    downloadArtifact(input?: TreeDxArtifactExportRequest): Promise<TreeDxArtifactDownload>;
+}

package/dist/treedx/support/registry-client.d.ts

@@ -0,0 +1,11 @@
+import type { TreeDxClientOptions, TreeDxNode, TreeDxRepositoryPlacement } from '../types.js';
+import { TreeDxClient } from './client.js';
+export interface TreeDxRegistryClientOptions extends TreeDxClientOptions {
+}
+export declare class TreeDxRegistryClient {
+    readonly client: TreeDxClient;
+    constructor(options: TreeDxRegistryClientOptions | TreeDxClient);
+    listNodes(): Promise<TreeDxNode[]>;
+    resolveRepository(repoId: string): Promise<TreeDxRepositoryPlacement>;
+    resolveRepositories(repoIds: string[]): Promise<TreeDxRepositoryPlacement[]>;
+}

package/dist/treedx/support/sdk-integration.d.ts

@@ -0,0 +1,27 @@
+import { TreeDxFederatedClient } from '../federation/federated-client.js';
+import { TreeDxClient, type TreeDxClientOptions } from './client.js';
+import { TreeDxRegistryClient, type TreeDxRegistryClientOptions } from './registry-client.js';
+export interface AgentSdkTreeDxOptions {
+    enabled: boolean;
+    client?: TreeDxClient | TreeDxClientOptions;
+    baseUrl?: string;
+    token?: string;
+    repoId?: string;
+    contentPathMap?: Record<string, string>;
+    registryRouting?: boolean;
+    registryClient?: TreeDxRegistryClient | TreeDxRegistryClientOptions;
+    federatedClient?: TreeDxFederatedClient;
+    defaultRef?: string;
+    defaultAuthor?: {
+        name: string;
+        email: string;
+    };
+    branchPrefix?: string;
+}
+export interface AgentSdkTreeDxIntegration {
+    client: TreeDxClient;
+    repoId: string;
+    registry?: TreeDxRegistryClient;
+    federated?: TreeDxFederatedClient;
+}
+export declare function resolveAgentTreeDxIntegration(options: AgentSdkTreeDxOptions): AgentSdkTreeDxIntegration;