@treeseed/sdk 0.10.27 → 0.11.0

package/dist/treedx-client.d.ts

@@ -0,0 +1,86 @@
+export interface TreeDxClientConfig {
+    baseUrl: string;
+    token?: string;
+    fetchImpl?: typeof fetch;
+    transport?: Transport;
+    defaultHeaders?: Record<string, string>;
+}
+export interface TreeDxRequest {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+    body?: unknown;
+    binaryBody?: Uint8Array | ArrayBuffer | Buffer | ReadableStream<Uint8Array>;
+}
+export interface TreeDxResponse<T = unknown> {
+    status: number;
+    headers: Record<string, string>;
+    data: T;
+}
+export interface Transport {
+    request<T = unknown>(request: TreeDxRequest): Promise<TreeDxResponse<T>>;
+}
+export declare class TreeDxApiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details?: unknown;
+    readonly payload?: unknown;
+    readonly cause?: unknown;
+    constructor(input: {
+        status: number;
+        code: string;
+        message: string;
+        details?: unknown;
+        payload?: unknown;
+        cause?: unknown;
+    });
+    static fromResponse(status: number, payload: unknown): TreeDxApiError;
+    static network(message: string, cause?: unknown): TreeDxApiError;
+}
+export declare class TreeDxClient {
+    readonly config: TreeDxClientConfig;
+    readonly transport: Transport;
+    readonly repositories: RepositoriesAdapter;
+    readonly query: QueryAdapter;
+    readonly files: FilesAdapter;
+    readonly graph: GraphAdapter;
+    readonly federation: FederationAdapter;
+    readonly exec: ExecAdapter;
+    constructor(config: TreeDxClientConfig);
+}
+declare class RepositoriesAdapter {
+    private readonly transport;
+    constructor(transport: Transport);
+    list(): Promise<unknown>;
+}
+declare class QueryAdapter {
+    private readonly transport;
+    constructor(transport: Transport);
+    readFile(repoId: string, body: unknown): Promise<unknown>;
+    listPaths(repoId: string, body: unknown): Promise<unknown>;
+    searchFiles(repoId: string, body: unknown): Promise<unknown>;
+}
+declare class FilesAdapter {
+    private readonly transport;
+    constructor(transport: Transport);
+    write(workspaceId: string, body: unknown): Promise<unknown>;
+    patch(workspaceId: string, body: unknown): Promise<unknown>;
+}
+declare class GraphAdapter {
+    private readonly transport;
+    constructor(transport: Transport);
+    refresh(repoId: string, body: unknown): Promise<unknown>;
+}
+declare class FederationAdapter {
+    private readonly transport;
+    constructor(transport: Transport);
+    graphQuery(body: unknown): Promise<unknown>;
+    contextBuild(body: unknown): Promise<unknown>;
+}
+declare class ExecAdapter {
+    private readonly transport;
+    constructor(transport: Transport);
+    run(workspaceId: string, body: unknown): Promise<unknown>;
+}
+export {};

package/dist/treedx-client.js

@@ -0,0 +1,175 @@
+class TreeDxApiError extends Error {
+  status;
+  code;
+  details;
+  payload;
+  cause;
+  constructor(input) {
+    super(input.message);
+    this.name = "TreeDxApiError";
+    this.status = input.status;
+    this.code = input.code;
+    this.details = input.details;
+    this.payload = input.payload;
+    this.cause = input.cause;
+  }
+  static fromResponse(status, payload) {
+    const envelope = payload;
+    return new TreeDxApiError({
+      status,
+      code: envelope?.error?.code ?? "internal_error",
+      message: envelope?.error?.message ?? `TreeDX request failed with status ${status}`,
+      details: envelope?.error?.details,
+      payload
+    });
+  }
+  static network(message, cause) {
+    return new TreeDxApiError({
+      status: 0,
+      code: "network_error",
+      message,
+      cause
+    });
+  }
+}
+class FetchTreeDxTransport {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async request(request) {
+    const fetchImpl = this.config.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) throw TreeDxApiError.network("fetch is not available in this runtime");
+    const url = new URL(request.path, this.config.baseUrl);
+    for (const [key, value] of Object.entries(request.query ?? {})) {
+      if (value !== void 0) url.searchParams.set(key, String(value));
+    }
+    const headers = new Headers({
+      ...this.config.defaultHeaders ?? {},
+      ...request.headers ?? {}
+    });
+    if (this.config.token) headers.set("Authorization", `Bearer ${this.config.token}`);
+    let body;
+    if (request.binaryBody) {
+      body = request.binaryBody;
+    } else if (request.body !== void 0) {
+      headers.set("Content-Type", headers.get("Content-Type") ?? "application/json");
+      body = JSON.stringify(request.body);
+    }
+    try {
+      const response = await fetchImpl(url, {
+        method: request.method,
+        headers,
+        body
+      });
+      const contentType = response.headers.get("content-type") ?? "";
+      const data = contentType.includes("application/json") ? await response.json() : await response.text();
+      if (!response.ok) throw TreeDxApiError.fromResponse(response.status, data);
+      return {
+        status: response.status,
+        headers: Object.fromEntries(response.headers.entries()),
+        data
+      };
+    } catch (error) {
+      if (error instanceof TreeDxApiError) throw error;
+      throw TreeDxApiError.network(error instanceof Error ? error.message : "TreeDX request failed", error);
+    }
+  }
+}
+function segment(value) {
+  return encodeURIComponent(value);
+}
+async function requestData(transport, request) {
+  const response = await transport.request(request);
+  return response.data;
+}
+class TreeDxClient {
+  constructor(config) {
+    this.config = config;
+    this.transport = config.transport ?? new FetchTreeDxTransport(config);
+    this.repositories = new RepositoriesAdapter(this.transport);
+    this.query = new QueryAdapter(this.transport);
+    this.files = new FilesAdapter(this.transport);
+    this.graph = new GraphAdapter(this.transport);
+    this.federation = new FederationAdapter(this.transport);
+    this.exec = new ExecAdapter(this.transport);
+  }
+  config;
+  transport;
+  repositories;
+  query;
+  files;
+  graph;
+  federation;
+  exec;
+}
+class RepositoriesAdapter {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  list() {
+    return requestData(this.transport, { method: "GET", path: "/api/v1/repos" });
+  }
+}
+class QueryAdapter {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  readFile(repoId, body) {
+    return requestData(this.transport, { method: "POST", path: `/api/v1/repos/${segment(repoId)}/files/read`, body });
+  }
+  listPaths(repoId, body) {
+    return requestData(this.transport, { method: "POST", path: `/api/v1/repos/${segment(repoId)}/paths/list`, body });
+  }
+  searchFiles(repoId, body) {
+    return requestData(this.transport, { method: "POST", path: `/api/v1/repos/${segment(repoId)}/search/files`, body });
+  }
+}
+class FilesAdapter {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  write(workspaceId, body) {
+    return requestData(this.transport, { method: "PUT", path: `/api/v1/workspaces/${segment(workspaceId)}/files`, body });
+  }
+  patch(workspaceId, body) {
+    return requestData(this.transport, { method: "PATCH", path: `/api/v1/workspaces/${segment(workspaceId)}/files`, body });
+  }
+}
+class GraphAdapter {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  refresh(repoId, body) {
+    return requestData(this.transport, { method: "POST", path: `/api/v1/repos/${segment(repoId)}/graph/refresh`, body });
+  }
+}
+class FederationAdapter {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  graphQuery(body) {
+    return requestData(this.transport, { method: "POST", path: "/api/v1/graph/query", body });
+  }
+  contextBuild(body) {
+    return requestData(this.transport, { method: "POST", path: "/api/v1/context/build", body });
+  }
+}
+class ExecAdapter {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  run(workspaceId, body) {
+    return requestData(this.transport, { method: "POST", path: `/api/v1/workspaces/${segment(workspaceId)}/exec`, body });
+  }
+}
+export {
+  TreeDxApiError,
+  TreeDxClient
+};