@treeseed/treedx 0.1.1

package/README.md

@@ -0,0 +1,208 @@
+# TypeScript TreeDX SDK
+
+`@treeseed/treedx` is the generic TypeScript SDK for TreeDX. It implements the
+shared `packages/sdk-spec` architecture, follows `docs/api/openapi.yaml`, and
+does not encode TreeSeed product semantics. `packages/trsd-sdk` is a downstream
+TreeSeed consumer/reference only.
+
+The current `sdk-manifest.yaml` reports modules, capabilities, and test roots as
+`implemented`. The SDK exposes all 113 `/api/v1` OpenAPI operations through
+first-class module methods and a validated raw operation fallback.
+
+## Install
+
+```bash
+npm install @treeseed/treedx
+```
+
+Import the package as:
+
+```ts
+import { TreeDxClient, TreeDxApiError } from '@treeseed/treedx';
+```
+
+## Configure Client
+
+```ts
+import { TreeDxClient } from '@treeseed/treedx';
+
+const client = new TreeDxClient({
+  baseUrl: 'http://localhost:4000',
+  token: process.env.TREEDX_TOKEN
+});
+```
+
+The client also accepts a custom auth provider, custom transport, and default
+headers for tests or embedding.
+
+## Authenticate
+
+Bearer authentication uses the `Authorization: Bearer <token>` header. Tokens
+may come from `token` or an auth provider. The SDK must not place production
+identity in request JSON and must not log bearer tokens.
+
+## Basic Health Call
+
+```ts
+const health = await client.health();
+const version = await client.version();
+```
+
+## Repository Query
+
+Repository-scoped query helpers live under `client.query`:
+
+```ts
+const result = await client.query.searchFiles('repo_demo', {
+  query: 'release provenance',
+  paths: ['docs/**']
+});
+
+const file = await client.query.readFile('repo_demo', {
+  ref: 'refs/heads/main',
+  path: 'docs/index.md'
+});
+```
+
+## Workspace File Lifecycle
+
+Workspace-scoped file helpers live under `client.workspaces` and
+`client.files`:
+
+```ts
+const workspace = await client.workspaces.create('repo_demo', {
+  ref: 'refs/heads/main'
+});
+
+await client.files.write('workspace_123', {
+  path: 'docs/new.md',
+  content: '# New'
+});
+
+await client.files.patch('workspace_123', {
+  path: 'docs/new.md',
+  patch: '...'
+});
+
+await client.files.commit('workspace_123', {
+  message: 'Update docs'
+});
+
+await client.workspaces.close('workspace_123');
+```
+
+## Blob Upload And Download
+
+Binary helpers preserve byte payloads and do not coerce arbitrary text strings
+into binary upload bodies.
+
+```ts
+await client.blobs.upload('workspace_123', new Uint8Array([1, 2, 3]));
+const blob = await client.blobs.download('workspace_123', { path: 'asset.bin' });
+```
+
+Multipart helpers expose create, part upload, complete, and abort:
+
+```ts
+const upload = await client.blobs.createMultipartUpload('workspace_123', {
+  path: 'large.bin'
+});
+
+await client.blobs.uploadPart('workspace_123', upload.uploadId, 1, new Uint8Array([1]));
+await client.blobs.completeMultipartUpload('workspace_123', upload.uploadId, {
+  parts: [{ partNumber: 1 }]
+});
+```
+
+## Graph And Context Query
+
+```ts
+await client.graph.refresh('repo_demo');
+const graph = await client.graph.query('repo_demo', { query: 'MATCH ...' });
+const context = await client.context.build('repo_demo', { query: 'ctx docs' });
+const parsed = await client.context.parse('repo_demo', { source: 'ctx docs' });
+```
+
+## Federated Query
+
+Federation helpers use portfolio/global TreeDX routes rather than a single
+configured repository:
+
+```ts
+const plan = await client.federation.plan({ query: 'release provenance' });
+const results = await client.federation.search({ query: 'release provenance' });
+```
+
+## Scoped Admin And Internal Modules
+
+Full OpenAPI coverage includes sensitive scoped modules: Admin, Audit, Policy,
+SearchIndex, and FederationInternal. These APIs require appropriate TreeDX
+credentials and should be used carefully against production systems. They remain
+generic TreeDX APIs and do not encode TreeSeed product semantics.
+
+The raw operation fallback validates method/path pairs against generated OpenAPI
+metadata before dispatch.
+
+## Error Handling
+
+Non-2xx responses and network failures surface as `TreeDxApiError` with
+`status`, `code`, `message`, `details`, and `payload`. Network failures use
+`status = 0` and `code = "network_error"`.
+
+```ts
+try {
+  await client.whoami();
+} catch (error) {
+  if (error instanceof TreeDxApiError) {
+    console.error(error.status, error.code, error.message);
+  }
+}
+```
+
+## Pagination
+
+Pagination helpers preserve opaque cursor values and page metadata. SDK code
+must not decode TreeDX cursor internals.
+
+```ts
+import { getNextCursor } from '@treeseed/treedx/treedx/client';
+```
+
+## Binary And Multipart
+
+Binary bodies may be `Uint8Array`, `ArrayBuffer`, `Buffer`, or
+`ReadableStream<Uint8Array>`. Multipart part numbers are passed through to
+TreeDX without SDK renumbering.
+
+## Conformance
+
+The shared scenario catalog loads through `TreeDxConformanceAdapter`. Live
+conformance runs against the local TreeDX harness for implemented SDK
+verification. Optional integration checks may still report a clean
+not-configured path when no server is configured.
+
+```bash
+npm run test:treedx-conformance
+```
+
+## Integration
+
+Integration tests call a live TreeDX server only when `TREEDX_BASE_URL` is set.
+Without that environment variable, they pass cleanly by reporting
+not-configured behavior.
+
+```bash
+npm run test:treedx-integration
+```
+
+## Development Commands
+
+```bash
+npm ci
+npm run treedx:check-generated
+npm run build
+npm run test:treedx-unit
+npm run test:treedx-conformance
+npm run test:treedx-integration
+npm test
+```

package/dist/treedx/adapters/admin.d.ts

@@ -0,0 +1,20 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class AdminAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    deepHealth(): Promise<unknown>;
+    storageHealth(): Promise<unknown>;
+    storageCheck(input?: unknown): Promise<unknown>;
+    storageRecover(input?: unknown): Promise<unknown>;
+    storageCompact(input?: unknown): Promise<unknown>;
+    storageBackup(input?: unknown): Promise<unknown>;
+    storageMigrations(): Promise<unknown>;
+    storageMigrationPlan(input: unknown): Promise<unknown>;
+    storageMigrationApply(input: unknown): Promise<unknown>;
+    storageMigrationRollback(input: unknown): Promise<unknown>;
+    storageRestoreVerify(input: unknown): Promise<unknown>;
+    storageRestore(input: unknown): Promise<unknown>;
+    quarantinedWorkspaces(): Promise<unknown>;
+    cleanupArtifacts(input?: unknown): Promise<unknown>;
+    importLocalRepo(input: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/admin.js

@@ -0,0 +1,22 @@
+import { jsonRequest } from './common.js';
+export class AdminAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    deepHealth() { return jsonRequest(this.context.transport, 'GET', '/api/v1/admin/health/deep'); }
+    storageHealth() { return jsonRequest(this.context.transport, 'GET', '/api/v1/admin/storage/health'); }
+    storageCheck(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/check', input); }
+    storageRecover(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/recover', input); }
+    storageCompact(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/compact', input); }
+    storageBackup(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/backup', input); }
+    storageMigrations() { return jsonRequest(this.context.transport, 'GET', '/api/v1/admin/storage/migrations'); }
+    storageMigrationPlan(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/migrations/plan', input); }
+    storageMigrationApply(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/migrations/apply', input); }
+    storageMigrationRollback(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/migrations/rollback', input); }
+    storageRestoreVerify(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/restore/verify', input); }
+    storageRestore(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/storage/restore', input); }
+    quarantinedWorkspaces() { return jsonRequest(this.context.transport, 'GET', '/api/v1/admin/workspaces/quarantined'); }
+    cleanupArtifacts(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/artifacts/cleanup', input); }
+    importLocalRepo(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/admin/repos/import-local', input); }
+}

package/dist/treedx/adapters/artifacts.d.ts

@@ -0,0 +1,9 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class ArtifactsAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    export(repoId: string, input: unknown): Promise<unknown>;
+    list(repoId: string): Promise<unknown>;
+    get(repoId: string, artifactId: string): Promise<unknown>;
+    delete(repoId: string, artifactId: string): Promise<unknown>;
+}

package/dist/treedx/adapters/artifacts.js

@@ -0,0 +1,11 @@
+import { jsonRequest, segment } from './common.js';
+export class ArtifactsAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    export(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/artifacts/export`, input); }
+    list(repoId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/artifacts`); }
+    get(repoId, artifactId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/artifacts/${segment(artifactId)}`); }
+    delete(repoId, artifactId) { return jsonRequest(this.context.transport, 'DELETE', `/api/v1/repos/${segment(repoId)}/artifacts/${segment(artifactId)}`); }
+}

package/dist/treedx/adapters/audit.d.ts

@@ -0,0 +1,6 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class AuditAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    events(query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+}

package/dist/treedx/adapters/audit.js

@@ -0,0 +1,8 @@
+import { jsonRequest } from './common.js';
+export class AuditAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    events(query) { return jsonRequest(this.context.transport, 'GET', '/api/v1/audit/events', undefined, query); }
+}

package/dist/treedx/adapters/blobs.d.ts

@@ -0,0 +1,15 @@
+import { type TreeDxAdapterContext } from './common.js';
+import type { BinaryBody } from '../types/index.js';
+export declare class BlobsAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    read(repoId: string, input: unknown): Promise<unknown>;
+    write(workspaceId: string, input: unknown): Promise<unknown>;
+    delete(workspaceId: string, input: unknown): Promise<unknown>;
+    download(workspaceId: string, query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    upload(workspaceId: string, body: BinaryBody, query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    createMultipartUpload(workspaceId: string, input: unknown): Promise<unknown>;
+    uploadPart(workspaceId: string, uploadId: string, partNumber: number, body: BinaryBody): Promise<unknown>;
+    completeMultipartUpload(workspaceId: string, uploadId: string, input: unknown): Promise<unknown>;
+    abortMultipartUpload(workspaceId: string, uploadId: string): Promise<unknown>;
+}

package/dist/treedx/adapters/blobs.js

@@ -0,0 +1,16 @@
+import { binaryRequest, jsonRequest, segment } from './common.js';
+export class BlobsAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    read(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/blobs/read`, input); }
+    write(workspaceId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/workspaces/${segment(workspaceId)}/blobs/write`, input); }
+    delete(workspaceId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/workspaces/${segment(workspaceId)}/blobs/delete`, input); }
+    download(workspaceId, query) { return jsonRequest(this.context.transport, 'GET', `/api/v1/workspaces/${segment(workspaceId)}/blobs/download`, undefined, query); }
+    upload(workspaceId, body, query) { return binaryRequest(this.context.transport, 'PUT', `/api/v1/workspaces/${segment(workspaceId)}/blobs/upload`, body, query); }
+    createMultipartUpload(workspaceId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/workspaces/${segment(workspaceId)}/blobs/uploads`, input); }
+    uploadPart(workspaceId, uploadId, partNumber, body) { return binaryRequest(this.context.transport, 'PUT', `/api/v1/workspaces/${segment(workspaceId)}/blobs/uploads/${segment(uploadId)}/parts/${partNumber}`, body); }
+    completeMultipartUpload(workspaceId, uploadId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/workspaces/${segment(workspaceId)}/blobs/uploads/${segment(uploadId)}/complete`, input); }
+    abortMultipartUpload(workspaceId, uploadId) { return jsonRequest(this.context.transport, 'DELETE', `/api/v1/workspaces/${segment(workspaceId)}/blobs/uploads/${segment(uploadId)}`); }
+}

package/dist/treedx/adapters/common.d.ts

@@ -0,0 +1,7 @@
+import type { BinaryBody, Transport, TreeDxHttpMethod } from '../types/index.js';
+export interface TreeDxAdapterContext {
+    transport: Transport;
+}
+export declare function segment(value: string): string;
+export declare function jsonRequest<T>(transport: Transport, method: TreeDxHttpMethod, path: string, body?: unknown, query?: Record<string, string | number | boolean | undefined>): Promise<T>;
+export declare function binaryRequest<T>(transport: Transport, method: TreeDxHttpMethod, path: string, binaryBody: BinaryBody, query?: Record<string, string | number | boolean | undefined>): Promise<T>;

package/dist/treedx/adapters/common.js

@@ -0,0 +1,11 @@
+export function segment(value) {
+    return encodeURIComponent(value);
+}
+export async function jsonRequest(transport, method, path, body, query) {
+    const response = await transport.request({ method, path, body, query });
+    return response.data;
+}
+export async function binaryRequest(transport, method, path, binaryBody, query) {
+    const response = await transport.request({ method, path, binaryBody, query });
+    return response.data;
+}

package/dist/treedx/adapters/context.d.ts

@@ -0,0 +1,7 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class ContextAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    build(repoId: string, input: unknown): Promise<unknown>;
+    parse(repoId: string, input: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/context.js

@@ -0,0 +1,9 @@
+import { jsonRequest, segment } from './common.js';
+export class ContextAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    build(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/context/build`, input); }
+    parse(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/context/parse-ctx`, input); }
+}

package/dist/treedx/adapters/exec.d.ts

@@ -0,0 +1,6 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class ExecAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    run(workspaceId: string, input: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/exec.js

@@ -0,0 +1,8 @@
+import { jsonRequest, segment } from './common.js';
+export class ExecAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    run(workspaceId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/workspaces/${segment(workspaceId)}/exec`, input); }
+}

package/dist/treedx/adapters/federation-internal.d.ts

@@ -0,0 +1,9 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class FederationInternalAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    health(): Promise<unknown>;
+    proxy(input: unknown): Promise<unknown>;
+    exportMirror(repoId: string, input: unknown): Promise<unknown>;
+    importMirror(repoId: string, input: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/federation-internal.js

@@ -0,0 +1,11 @@
+import { jsonRequest, segment } from './common.js';
+export class FederationInternalAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    health() { return jsonRequest(this.context.transport, 'GET', '/api/v1/internal/federation/health'); }
+    proxy(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/internal/federation/proxy', input); }
+    exportMirror(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/internal/federation/repos/${segment(repoId)}/mirror/export`, input); }
+    importMirror(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/internal/federation/repos/${segment(repoId)}/mirror/import`, input); }
+}

package/dist/treedx/adapters/federation.d.ts

@@ -0,0 +1,20 @@
+import { segment, type TreeDxAdapterContext } from './common.js';
+export declare class FederationAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    plan(input: unknown): Promise<unknown>;
+    search(input: unknown): Promise<unknown>;
+    query(input: unknown): Promise<unknown>;
+    contextBuild(input: unknown): Promise<unknown>;
+    graphQuery(input: unknown): Promise<unknown>;
+    catalog(): Promise<unknown>;
+    pushCatalog(input?: unknown): Promise<unknown>;
+    syncCatalog(input?: unknown): Promise<unknown>;
+    peers(): Promise<unknown>;
+    peer(nodeId: string): Promise<unknown>;
+    registerNode(input: unknown): Promise<unknown>;
+    trustPeer(nodeId: string, input?: unknown): Promise<unknown>;
+    revokePeer(nodeId: string, input?: unknown): Promise<unknown>;
+    routes(): Promise<unknown>;
+}
+export { segment };

package/dist/treedx/adapters/federation.js

@@ -0,0 +1,22 @@
+import { jsonRequest, segment } from './common.js';
+export class FederationAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    plan(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/federation/query/plan', input); }
+    search(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/search', input); }
+    query(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/query', input); }
+    contextBuild(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/context/build', input); }
+    graphQuery(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/graph/query', input); }
+    catalog() { return jsonRequest(this.context.transport, 'GET', '/api/v1/federation/catalog'); }
+    pushCatalog(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/federation/catalog/push', input); }
+    syncCatalog(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/federation/catalog/sync', input); }
+    peers() { return jsonRequest(this.context.transport, 'GET', '/api/v1/federation/peers'); }
+    peer(nodeId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/federation/peers/${segment(nodeId)}`); }
+    registerNode(input) { return jsonRequest(this.context.transport, 'POST', '/api/v1/federation/nodes/register', input); }
+    trustPeer(nodeId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/federation/peers/${segment(nodeId)}/trust`, input); }
+    revokePeer(nodeId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/federation/peers/${segment(nodeId)}/revoke`, input); }
+    routes() { return jsonRequest(this.context.transport, 'GET', '/api/v1/federation/routes'); }
+}
+export { segment };

package/dist/treedx/adapters/files.d.ts

@@ -0,0 +1,14 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class FilesAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    tree(workspaceId: string, query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    read(workspaceId: string, query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    write(workspaceId: string, input: unknown): Promise<unknown>;
+    patch(workspaceId: string, input: unknown): Promise<unknown>;
+    delete(workspaceId: string, query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    search(workspaceId: string, input: unknown): Promise<unknown>;
+    status(workspaceId: string): Promise<unknown>;
+    diff(workspaceId: string, query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    commit(workspaceId: string, input: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/files.js

@@ -0,0 +1,16 @@
+import { jsonRequest, segment } from './common.js';
+export class FilesAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    tree(workspaceId, query) { return jsonRequest(this.context.transport, 'GET', `/api/v1/workspaces/${segment(workspaceId)}/tree`, undefined, query); }
+    read(workspaceId, query) { return jsonRequest(this.context.transport, 'GET', `/api/v1/workspaces/${segment(workspaceId)}/files`, undefined, query); }
+    write(workspaceId, input) { return jsonRequest(this.context.transport, 'PUT', `/api/v1/workspaces/${segment(workspaceId)}/files`, input); }
+    patch(workspaceId, input) { return jsonRequest(this.context.transport, 'PATCH', `/api/v1/workspaces/${segment(workspaceId)}/files`, input); }
+    delete(workspaceId, query) { return jsonRequest(this.context.transport, 'DELETE', `/api/v1/workspaces/${segment(workspaceId)}/files`, undefined, query); }
+    search(workspaceId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/workspaces/${segment(workspaceId)}/search`, input); }
+    status(workspaceId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/workspaces/${segment(workspaceId)}/status`); }
+    diff(workspaceId, query) { return jsonRequest(this.context.transport, 'GET', `/api/v1/workspaces/${segment(workspaceId)}/diff`, undefined, query); }
+    commit(workspaceId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/workspaces/${segment(workspaceId)}/commit`, input); }
+}

package/dist/treedx/adapters/graph.d.ts

@@ -0,0 +1,14 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class GraphAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    refresh(repoId: string, input?: unknown): Promise<unknown>;
+    query(repoId: string, input: unknown): Promise<unknown>;
+    refreshJob(repoId: string, jobId: string): Promise<unknown>;
+    node(repoId: string, nodeId: string, query?: Record<string, string | number | boolean | undefined>): Promise<unknown>;
+    related(repoId: string, input: unknown): Promise<unknown>;
+    subgraph(repoId: string, input: unknown): Promise<unknown>;
+    searchFiles(repoId: string, input: unknown): Promise<unknown>;
+    searchSections(repoId: string, input: unknown): Promise<unknown>;
+    searchEntities(repoId: string, input: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/graph.js

@@ -0,0 +1,16 @@
+import { jsonRequest, segment } from './common.js';
+export class GraphAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    refresh(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/graph/refresh`, input); }
+    query(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/graph/query`, input); }
+    refreshJob(repoId, jobId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/graph/refresh-jobs/${segment(jobId)}`); }
+    node(repoId, nodeId, query) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/graph/nodes/${segment(nodeId)}`, undefined, query); }
+    related(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/graph/related`, input); }
+    subgraph(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/graph/subgraph`, input); }
+    searchFiles(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/graph/search-files`, input); }
+    searchSections(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/graph/search-sections`, input); }
+    searchEntities(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/graph/search-entities`, input); }
+}

package/dist/treedx/adapters/index.d.ts

@@ -0,0 +1,21 @@
+export * from './common.js';
+export * from './repositories.js';
+export * from './workspaces.js';
+export * from './files.js';
+export * from './blobs.js';
+export * from './query.js';
+export * from './graph.js';
+export * from './context.js';
+export * from './federation.js';
+export * from './registry.js';
+export * from './snapshots.js';
+export * from './artifacts.js';
+export * from './mirrors.js';
+export * from './migrations.js';
+export * from './exec.js';
+export * from './observability.js';
+export * from './admin.js';
+export * from './audit.js';
+export * from './policy.js';
+export * from './search-index.js';
+export * from './federation-internal.js';

package/dist/treedx/adapters/index.js

@@ -0,0 +1,21 @@
+export * from './common.js';
+export * from './repositories.js';
+export * from './workspaces.js';
+export * from './files.js';
+export * from './blobs.js';
+export * from './query.js';
+export * from './graph.js';
+export * from './context.js';
+export * from './federation.js';
+export * from './registry.js';
+export * from './snapshots.js';
+export * from './artifacts.js';
+export * from './mirrors.js';
+export * from './migrations.js';
+export * from './exec.js';
+export * from './observability.js';
+export * from './admin.js';
+export * from './audit.js';
+export * from './policy.js';
+export * from './search-index.js';
+export * from './federation-internal.js';

package/dist/treedx/adapters/migrations.d.ts

@@ -0,0 +1,7 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class MigrationsAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    create(repoId: string, input: unknown): Promise<unknown>;
+    get(repoId: string, migrationId: string): Promise<unknown>;
+}

package/dist/treedx/adapters/migrations.js

@@ -0,0 +1,9 @@
+import { jsonRequest, segment } from './common.js';
+export class MigrationsAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    create(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/migrations`, input); }
+    get(repoId, migrationId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/migrations/${segment(migrationId)}`); }
+}

package/dist/treedx/adapters/mirrors.d.ts

@@ -0,0 +1,10 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class MirrorsAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    list(repoId: string): Promise<unknown>;
+    upsert(repoId: string, input: unknown): Promise<unknown>;
+    sync(repoId: string, mirrorId: string, input?: unknown): Promise<unknown>;
+    health(repoId: string, mirrorId: string, input?: unknown): Promise<unknown>;
+    promote(repoId: string, mirrorId: string, input?: unknown): Promise<unknown>;
+}

package/dist/treedx/adapters/mirrors.js

@@ -0,0 +1,12 @@
+import { jsonRequest, segment } from './common.js';
+export class MirrorsAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    list(repoId) { return jsonRequest(this.context.transport, 'GET', `/api/v1/repos/${segment(repoId)}/mirrors`); }
+    upsert(repoId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/mirrors`, input); }
+    sync(repoId, mirrorId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/mirrors/${segment(mirrorId)}/sync`, input); }
+    health(repoId, mirrorId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/mirrors/${segment(mirrorId)}/health`, input); }
+    promote(repoId, mirrorId, input) { return jsonRequest(this.context.transport, 'POST', `/api/v1/repos/${segment(repoId)}/mirrors/${segment(mirrorId)}/promote`, input); }
+}

package/dist/treedx/adapters/observability.d.ts

@@ -0,0 +1,9 @@
+import { type TreeDxAdapterContext } from './common.js';
+export declare class ObservabilityAdapter {
+    private readonly context;
+    constructor(context: TreeDxAdapterContext);
+    health(): Promise<unknown>;
+    ready(): Promise<unknown>;
+    deepHealth(): Promise<unknown>;
+    metrics(): Promise<unknown>;
+}

package/dist/treedx/adapters/observability.js

@@ -0,0 +1,11 @@
+import { jsonRequest } from './common.js';
+export class ObservabilityAdapter {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    health() { return jsonRequest(this.context.transport, 'GET', '/api/v1/health'); }
+    ready() { return jsonRequest(this.context.transport, 'GET', '/api/v1/ready'); }
+    deepHealth() { return jsonRequest(this.context.transport, 'GET', '/api/v1/health/deep'); }
+    metrics() { return jsonRequest(this.context.transport, 'GET', '/api/v1/metrics'); }
+}