@treeseed/sdk 0.10.28 → 0.11.0

package/dist/treedx/graph-adapter.d.ts

@@ -0,0 +1,33 @@
+import { TreeDxClient } from './client.ts';
+import type { SdkContextPack, SdkContextPackRequest, SdkGraphDslParseResult, SdkGraphNode, SdkGraphQueryOptions, SdkGraphQueryRequest, SdkGraphQueryResult, SdkGraphRefreshPayload, SdkGraphSearchOptions, SdkGraphSearchResult, SdkGraphSeedResolution, SdkGraphTraversalResult, TreeDxGraphRefreshRequest } from './types.ts';
+export interface TreeDxGraphAdapterOptions {
+    client: TreeDxClient;
+    repoId?: string;
+    defaultRef?: string;
+}
+export declare class TreeDxGraphAdapter {
+    private readonly options;
+    constructor(options: TreeDxGraphAdapterOptions);
+    refresh(request?: TreeDxGraphRefreshRequest): Promise<SdkGraphRefreshPayload>;
+    searchFiles(query: string, options?: SdkGraphSearchOptions): Promise<SdkGraphSearchResult[]>;
+    searchSections(query: string, options?: SdkGraphSearchOptions): Promise<SdkGraphSearchResult[]>;
+    searchEntities(query: string, options?: SdkGraphSearchOptions): Promise<SdkGraphSearchResult[]>;
+    getNode(id: string): Promise<SdkGraphNode | null>;
+    getNeighbors(id: string, options?: SdkGraphQueryOptions): Promise<SdkGraphTraversalResult>;
+    followReferences(id: string, options?: SdkGraphQueryOptions): Promise<SdkGraphTraversalResult>;
+    getBacklinks(id: string, options?: SdkGraphQueryOptions): Promise<SdkGraphTraversalResult>;
+    getRelated(id: string, options?: SdkGraphQueryOptions): Promise<SdkGraphTraversalResult>;
+    getSubgraph(seedIds: string[], options?: SdkGraphQueryOptions): Promise<SdkGraphTraversalResult>;
+    resolveSeeds(_request: SdkGraphQueryRequest): Promise<SdkGraphSeedResolution>;
+    queryGraph(request: SdkGraphQueryRequest): Promise<SdkGraphQueryResult>;
+    buildContextPack(request: SdkContextPackRequest): Promise<SdkContextPack>;
+    parseGraphDsl(source: string): Promise<SdkGraphDslParseResult>;
+    resolveReference(_reference?: string, _options?: {
+        fromNodeId?: string;
+        fromPath?: string;
+        models?: string[];
+    }): Promise<never>;
+    explainReferenceChain(_fromId?: string, _toId?: string): Promise<never>;
+    private related;
+    private unwrapNode;
+}

package/dist/treedx/graph-adapter.js

@@ -0,0 +1,156 @@
+import { TreeDxApiError } from "./errors.js";
+class TreeDxGraphAdapter {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async refresh(request = {}) {
+    return this.options.client.refreshGraph({
+      ...request,
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef
+    });
+  }
+  searchFiles(query, options) {
+    return this.options.client.searchGraphFiles({
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef,
+      query,
+      limit: options?.limit,
+      options
+    });
+  }
+  searchSections(query, options) {
+    return this.options.client.searchGraphSections({
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef,
+      query,
+      limit: options?.limit,
+      options
+    });
+  }
+  searchEntities(query, options) {
+    return this.options.client.searchGraphEntities({
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef,
+      query,
+      limit: options?.limit,
+      options
+    });
+  }
+  async getNode(id) {
+    try {
+      return await this.options.client.getGraphNode({
+        repoId: this.options.repoId,
+        ref: this.options.defaultRef,
+        nodeId: id
+      });
+    } catch (error) {
+      if (error instanceof TreeDxApiError && error.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  getNeighbors(id, options) {
+    return this.related(id, [], options);
+  }
+  followReferences(id, options) {
+    return this.related(id, ["references"], options);
+  }
+  getBacklinks(id, options) {
+    return this.related(id, [], { ...options, direction: "incoming" });
+  }
+  getRelated(id, options) {
+    return this.related(id, ["related"], options);
+  }
+  async getSubgraph(seedIds, options) {
+    const result = await this.options.client.getSubgraph({
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef,
+      seedIds,
+      options
+    });
+    return {
+      seedId: String(result.seedId ?? seedIds.join(",")),
+      nodes: (result.nodes ?? []).map((entry) => this.unwrapNode(entry)),
+      edges: result.edges ?? []
+    };
+  }
+  async resolveSeeds(_request) {
+    throw new TreeDxApiError("TreeDX remote graph seed resolution is not implemented by the TreeDX remote graph adapter.", {
+      status: 501,
+      code: "unsupported_treedx_graph_operation"
+    });
+  }
+  async queryGraph(request) {
+    const result = await this.options.client.queryGraph({
+      ...request,
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef
+    });
+    return {
+      seedIds: result.seedIds,
+      nodes: result.nodes,
+      edges: result.edges,
+      providerId: result.providerId,
+      diagnostics: result.diagnostics
+    };
+  }
+  async buildContextPack(request) {
+    const result = await this.options.client.buildContext({
+      ...request,
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef
+    });
+    return {
+      seedIds: result.seedIds,
+      totalTokenEstimate: result.totalTokenEstimate,
+      includedNodeIds: result.includedNodeIds,
+      nodes: result.nodes,
+      edges: result.edges
+    };
+  }
+  parseGraphDsl(source) {
+    return this.options.client.parseContextDsl({
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef,
+      source
+    });
+  }
+  resolveReference(_reference, _options) {
+    return Promise.reject(new TreeDxApiError("TreeDX remote reference resolution is not implemented by the TreeDX remote graph adapter.", {
+      status: 501,
+      code: "unsupported_treedx_graph_operation"
+    }));
+  }
+  explainReferenceChain(_fromId, _toId) {
+    return Promise.reject(new TreeDxApiError("TreeDX remote reference-chain explanation is not implemented by the TreeDX remote graph adapter.", {
+      status: 501,
+      code: "unsupported_treedx_graph_operation"
+    }));
+  }
+  async related(id, relations, options) {
+    const result = await this.options.client.getRelated({
+      repoId: this.options.repoId,
+      ref: this.options.defaultRef,
+      nodeId: id,
+      relations,
+      options
+    });
+    return {
+      seedId: id,
+      nodes: (result.nodes ?? []).map((entry) => this.unwrapNode(entry)),
+      edges: result.edges ?? []
+    };
+  }
+  unwrapNode(entry) {
+    if (typeof entry === "object" && entry !== null && "node" in entry) {
+      return entry.node;
+    }
+    return entry;
+  }
+}
+export {
+  TreeDxGraphAdapter
+};

package/dist/treedx/index.d.ts

@@ -0,0 +1,14 @@
+export { TREEDX_CLIENT_OPERATION_MAP, TreeDxClient } from './client.ts';
+export { TreeDxRegistryClient, type TreeDxRegistryClientOptions } from './registry-client.ts';
+export { TreeDxFederatedClient, type TreeDxFederatedClientOptions } from './federated-client.ts';
+export { TreeDxApiError } from './errors.ts';
+export { resolveAgentTreeDxIntegration, type AgentSdkTreeDxIntegration, type AgentSdkTreeDxOptions } from './sdk-integration.ts';
+export { TreeDxRepositoryAdapter, resolveContentDir, type TreeDxContentMutationResult, type TreeDxRepositoryAdapterOptions, } from './repository-adapter.ts';
+export { TreeDxQueryAdapter, type TreeDxQueryAdapterOptions } from './query-adapter.ts';
+export { TreeDxGraphAdapter, type TreeDxGraphAdapterOptions } from './graph-adapter.ts';
+export { TreeDxWorkspaceAdapter, type TreeDxWorkspaceAdapterOptions } from './workspace-adapter.ts';
+export * from './market-integration.ts';
+export { LocalGraphPort, LocalRepositoryPort, LocalRepositoryQueryPort, TreeDxArtifactPort, TreeDxExecPort, TreeDxFederatedPort, TreeDxGraphPort, TreeDxRegistryPort, TreeDxRepositoryPort, TreeDxRepositoryQueryPort, } from './ports.ts';
+export type * from './ports.ts';
+export type * from './types.ts';
+export type { components as TreeDxOpenApiComponents, operations as TreeDxOpenApiOperations, paths as TreeDxOpenApiPaths, } from './generated/openapi-types.ts';

package/dist/treedx/index.js

@@ -0,0 +1,48 @@
+import { TREEDX_CLIENT_OPERATION_MAP, TreeDxClient } from "./client.js";
+import { TreeDxRegistryClient } from "./registry-client.js";
+import { TreeDxFederatedClient } from "./federated-client.js";
+import { TreeDxApiError } from "./errors.js";
+import { resolveAgentTreeDxIntegration } from "./sdk-integration.js";
+import {
+  TreeDxRepositoryAdapter,
+  resolveContentDir
+} from "./repository-adapter.js";
+import { TreeDxQueryAdapter } from "./query-adapter.js";
+import { TreeDxGraphAdapter } from "./graph-adapter.js";
+import { TreeDxWorkspaceAdapter } from "./workspace-adapter.js";
+export * from "./market-integration.js";
+import {
+  LocalGraphPort,
+  LocalRepositoryPort,
+  LocalRepositoryQueryPort,
+  TreeDxArtifactPort,
+  TreeDxExecPort,
+  TreeDxFederatedPort,
+  TreeDxGraphPort,
+  TreeDxRegistryPort,
+  TreeDxRepositoryPort,
+  TreeDxRepositoryQueryPort
+} from "./ports.js";
+export {
+  LocalGraphPort,
+  LocalRepositoryPort,
+  LocalRepositoryQueryPort,
+  TREEDX_CLIENT_OPERATION_MAP,
+  TreeDxApiError,
+  TreeDxArtifactPort,
+  TreeDxClient,
+  TreeDxExecPort,
+  TreeDxFederatedClient,
+  TreeDxFederatedPort,
+  TreeDxGraphAdapter,
+  TreeDxGraphPort,
+  TreeDxQueryAdapter,
+  TreeDxRegistryClient,
+  TreeDxRegistryPort,
+  TreeDxRepositoryAdapter,
+  TreeDxRepositoryPort,
+  TreeDxRepositoryQueryPort,
+  TreeDxWorkspaceAdapter,
+  resolveAgentTreeDxIntegration,
+  resolveContentDir
+};

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

@@ -0,0 +1,27 @@
+import type { ProjectFilesystemRepositoryTopology, ProjectRepositoryTopology, TreeDxInstance, TreeDxProjectLibraryBinding } from '../sdk-types.ts';
+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/market-integration.js

@@ -0,0 +1,131 @@
+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
+      },
+      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 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)
+      },
+      r2: objectValue(content.r2)
+    },
+    siteRepository: site,
+    projectRepository: project
+  };
+}
+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/ports.d.ts

@@ -0,0 +1,166 @@
+import type { TreeDxClient } from './client.ts';
+import type { TreeDxFederatedClient } from './federated-client.ts';
+import type { TreeDxGraphAdapter } from './graph-adapter.ts';
+import type { TreeDxQueryAdapter } from './query-adapter.ts';
+import type { TreeDxRegistryClient } from './registry-client.ts';
+import type { TreeDxRepositoryAdapter } from './repository-adapter.ts';
+import type { TreeDxWorkspaceAdapter } from './workspace-adapter.ts';
+import type { ContentStore } from '../content-store.ts';
+import type { ContentGraphRuntime } from '../graph.ts';
+import type { SdkContentEntry, SdkFollowRequest, SdkGetRequest, SdkMutationRequest, SdkPickRequest, SdkSearchRequest } from '../sdk-types.ts';
+import type { TreeDxArtifact, TreeDxArtifactDownload, TreeDxArtifactExportRequest, TreeDxCommitRequest, TreeDxCommitResult, TreeDxCreateWorkspaceRequest, 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, TreeDxDeleteFileRequest } from './types.ts';
+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("../sdk-types.ts").SdkPickResult<SdkContentEntry>>;
+    create(input: SdkMutationRequest): Promise<{
+        item: SdkContentEntry;
+        git: import("../git-runtime.ts").GitMutationResult;
+    }>;
+    update(input: SdkMutationRequest): Promise<{
+        item: SdkContentEntry;
+        git: import("../git-runtime.ts").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.ts").SdkGraphRefreshPayload>;
+    searchFiles(query: string, options?: unknown): Promise<import("./types.ts").SdkGraphSearchResult[]>;
+    searchSections(query: string, options?: unknown): Promise<import("./types.ts").SdkGraphSearchResult[]>;
+    searchEntities(query: string, options?: unknown): Promise<import("./types.ts").SdkGraphSearchResult[]>;
+    getNode(id: string): Promise<import("./types.ts").SdkGraphNode | null>;
+    query(input: unknown): Promise<import("./types.ts").SdkGraphQueryResult>;
+    buildContext(input: unknown): Promise<import("./types.ts").SdkContextPack>;
+    parseDsl(source: string): Promise<import("./types.ts").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.ts").SdkGraphRefreshPayload>;
+    searchFiles(query: string, options?: unknown): Promise<import("./types.ts").SdkGraphSearchResult[]>;
+    searchSections(query: string, options?: unknown): Promise<import("./types.ts").SdkGraphSearchResult[]>;
+    searchEntities(query: string, options?: unknown): Promise<import("./types.ts").SdkGraphSearchResult[]>;
+    getNode(id: string, options?: unknown): Promise<import("./types.ts").SdkGraphNode | null>;
+    query(input: unknown): Promise<import("./types.ts").SdkGraphQueryResult>;
+    buildContext(input: unknown): Promise<import("./types.ts").SdkContextPack>;
+    parseDsl(source: string): Promise<import("./types.ts").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>;
+}