@treeseed/sdk 0.10.28 → 0.12.4

package/dist/treedx/ports.js

@@ -0,0 +1,231 @@
+class LocalRepositoryPort {
+  constructor(content) {
+    this.content = content;
+  }
+  content;
+  list(model) {
+    return this.content.list(model);
+  }
+  get(input) {
+    return this.content.get(input);
+  }
+  search(input) {
+    return this.content.search(input);
+  }
+  follow(input) {
+    return this.content.follow(input);
+  }
+  pick(input) {
+    return this.content.pick(input);
+  }
+  create(input) {
+    return this.content.create(input);
+  }
+  update(input) {
+    return this.content.update(input);
+  }
+}
+class LocalRepositoryQueryPort {
+  constructor(content) {
+    this.content = content;
+  }
+  content;
+  search(input) {
+    return this.content.search(input);
+  }
+  query(input) {
+    return this.content.search(input);
+  }
+}
+class LocalGraphPort {
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  runtime;
+  refresh(input) {
+    return this.runtime.refresh(input);
+  }
+  searchFiles(query, options) {
+    return this.runtime.searchFiles(query, options);
+  }
+  searchSections(query, options) {
+    return this.runtime.searchSections(query, options);
+  }
+  searchEntities(query, options) {
+    return this.runtime.searchEntities(query, options);
+  }
+  getNode(id) {
+    return this.runtime.getNode(id);
+  }
+  query(input) {
+    return this.runtime.queryGraph(input);
+  }
+  buildContext(input) {
+    return this.runtime.buildContextPack(input);
+  }
+  parseDsl(source) {
+    return this.runtime.parseGraphDsl(source);
+  }
+}
+class TreeDxRepositoryPort {
+  constructor(client, content, workspace) {
+    this.client = client;
+    this.content = content;
+    this.workspace = workspace;
+  }
+  client;
+  content;
+  workspace;
+  createWorkspace(input) {
+    return this.client.createWorkspace(input);
+  }
+  closeWorkspace(workspaceId) {
+    return this.client.closeWorkspace(workspaceId);
+  }
+  listTree(input) {
+    return this.client.listTree(input);
+  }
+  readFile(input) {
+    return this.client.readFile(input);
+  }
+  writeFile(input) {
+    return this.client.writeFile(input);
+  }
+  patchFile(input) {
+    return this.client.patchFile(input);
+  }
+  deleteFile(input) {
+    return this.client.deleteFile(input);
+  }
+  search(input) {
+    return this.client.search(input);
+  }
+  status(input) {
+    return this.client.status(input);
+  }
+  diff(input) {
+    return this.client.diff(input);
+  }
+  commit(input) {
+    return this.client.commit(input);
+  }
+  exec(input) {
+    return this.client.exec(input);
+  }
+}
+class TreeDxRepositoryQueryPort {
+  constructor(client, adapter) {
+    this.client = client;
+    this.adapter = adapter;
+  }
+  client;
+  adapter;
+  read(input) {
+    return this.client.readRepositoryFiles(input);
+  }
+  paths(input) {
+    return this.client.listRepositoryPaths(input);
+  }
+  query(input) {
+    return this.adapter?.queryRepository(input) ?? this.client.queryRepository(input);
+  }
+  search(input) {
+    return this.client.searchRepositoryFiles(input);
+  }
+}
+class TreeDxGraphPort {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  adapter;
+  refresh(input) {
+    return this.adapter.refresh(input);
+  }
+  searchFiles(query, options) {
+    return this.adapter.searchFiles(query, options);
+  }
+  searchSections(query, options) {
+    return this.adapter.searchSections(query, options);
+  }
+  searchEntities(query, options) {
+    return this.adapter.searchEntities(query, options);
+  }
+  getNode(id, options) {
+    return this.adapter.getNode(id, options);
+  }
+  query(input) {
+    return this.adapter.queryGraph(input);
+  }
+  buildContext(input) {
+    return this.adapter.buildContextPack(input);
+  }
+  parseDsl(source) {
+    return this.adapter.parseGraphDsl(source);
+  }
+}
+class TreeDxRegistryPort {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  resolveRepository(repoId) {
+    return this.client.resolveRepository(repoId);
+  }
+  resolveRepositories(repoIds) {
+    return this.client.resolveRepositories(repoIds);
+  }
+}
+class TreeDxFederatedPort {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  search(input) {
+    return this.client.federatedSearch(input);
+  }
+  query(input) {
+    return this.client.federatedQuery(input);
+  }
+  context(input) {
+    return this.client.federatedContext(input);
+  }
+  graph(input) {
+    return this.client.federatedGraph(input);
+  }
+}
+class TreeDxExecPort {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  exec(input) {
+    return this.client.exec(input);
+  }
+}
+class TreeDxArtifactPort {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  buildSnapshot(input = {}) {
+    return this.client.buildSnapshot(input);
+  }
+  exportArtifact(input = {}) {
+    return this.client.exportArtifact(input);
+  }
+  downloadArtifact(input = {}) {
+    return this.client.downloadArtifact(input);
+  }
+}
+export {
+  LocalGraphPort,
+  LocalRepositoryPort,
+  LocalRepositoryQueryPort,
+  TreeDxArtifactPort,
+  TreeDxExecPort,
+  TreeDxFederatedPort,
+  TreeDxGraphPort,
+  TreeDxRegistryPort,
+  TreeDxRepositoryPort,
+  TreeDxRepositoryQueryPort
+};

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

@@ -0,0 +1,19 @@
+import type { SdkContentEntry, SdkGetRequest, SdkModelRegistry, SdkSearchRequest } from '../sdk-types.js';
+import { TreeDxClient } from './client.js';
+import type { TreeDxRepositoryQueryRequest, TreeDxRepositoryQueryResult } from './types.js';
+export interface TreeDxQueryAdapterOptions {
+    client: TreeDxClient;
+    models: SdkModelRegistry;
+    repoRoot?: string;
+    contentPathMap?: Record<string, string>;
+    defaultRef?: string;
+}
+export declare class TreeDxQueryAdapter {
+    private readonly options;
+    constructor(options: TreeDxQueryAdapterOptions);
+    readContent(request: SdkGetRequest): Promise<SdkContentEntry | null>;
+    search(request: SdkSearchRequest): Promise<SdkContentEntry[]>;
+    searchContent(request: SdkSearchRequest): Promise<SdkContentEntry[]>;
+    query(input: TreeDxRepositoryQueryRequest): Promise<TreeDxRepositoryQueryResult>;
+    queryRepository(input: TreeDxRepositoryQueryRequest): Promise<TreeDxRepositoryQueryResult>;
+}

package/dist/treedx/query-adapter.js

@@ -0,0 +1,62 @@
+import {
+  entryFromTreeDxFile,
+  mapFilters,
+  mapSort,
+  resolveContentDir
+} from "./repository-adapter.js";
+import { resolveModelDefinition } from "../model-registry.js";
+class TreeDxQueryAdapter {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async readContent(request) {
+    const definition = resolveModelDefinition(request.model, this.options.models);
+    const contentDir = resolveContentDir(definition, this.options);
+    const candidates = [request.id, request.slug, request.key].filter((value) => Boolean(value));
+    for (const candidate of candidates) {
+      for (const extension of [".mdx", ".md"]) {
+        try {
+          const response = await this.options.client.readRepositoryFile({
+            ref: this.options.defaultRef,
+            path: `${contentDir}/${candidate}${extension}`,
+            parseFrontmatter: true
+          });
+          if (response.file) {
+            return entryFromTreeDxFile(definition, response.file, contentDir);
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  async search(request) {
+    return this.searchContent(request);
+  }
+  async searchContent(request) {
+    const definition = resolveModelDefinition(request.model, this.options.models);
+    const contentDir = resolveContentDir(definition, this.options);
+    const response = await this.options.client.searchRepositoryFiles({
+      ref: this.options.defaultRef,
+      paths: [`${contentDir}/**`],
+      query: "",
+      filters: mapFilters(definition, request.filters),
+      sort: mapSort(definition, request.sort),
+      limit: request.limit,
+      includeBody: true,
+      includeFrontmatter: true
+    });
+    const results = response.results ?? response.files ?? [];
+    return results.map((file) => entryFromTreeDxFile(definition, file, contentDir));
+  }
+  query(input) {
+    return this.options.client.queryRepository(input);
+  }
+  queryRepository(input) {
+    return this.query(input);
+  }
+}
+export {
+  TreeDxQueryAdapter
+};

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

@@ -0,0 +1,11 @@
+import { TreeDxClient } from './client.js';
+import type { TreeDxClientOptions, TreeDxNode, TreeDxRepositoryPlacement } from './types.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/registry-client.js

@@ -0,0 +1,19 @@
+import { TreeDxClient } from "./client.js";
+class TreeDxRegistryClient {
+  client;
+  constructor(options) {
+    this.client = options instanceof TreeDxClient ? options : new TreeDxClient(options);
+  }
+  listNodes() {
+    return this.client.listNodes();
+  }
+  resolveRepository(repoId) {
+    return this.client.getPlacement(repoId);
+  }
+  resolveRepositories(repoIds) {
+    return Promise.all(repoIds.map((repoId) => this.resolveRepository(repoId)));
+  }
+}
+export {
+  TreeDxRegistryClient
+};

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

@@ -0,0 +1,45 @@
+import type { SdkContentEntry, SdkFilterCondition, SdkFollowRequest, SdkGetRequest, SdkModelDefinition, SdkModelRegistry, SdkMutationRequest, SdkPickRequest, SdkPickResult, SdkSearchRequest, SdkSortSpec, SdkUpdateRequest } from '../sdk-types.js';
+import { TreeDxClient } from './client.js';
+import type { TreeDxCommitResult } from './types.js';
+export interface TreeDxRepositoryAdapterOptions {
+    client: TreeDxClient;
+    models: SdkModelRegistry;
+    repoRoot?: string;
+    defaultRef?: string;
+    defaultAuthor?: {
+        name: string;
+        email: string;
+    };
+    contentPathMap?: Record<string, string>;
+    branchPrefix?: string;
+}
+export interface TreeDxContentMutationResult {
+    item: SdkContentEntry;
+    git: TreeDxCommitResult;
+}
+export declare function resolveContentDir(definition: SdkModelDefinition, options: Pick<TreeDxRepositoryAdapterOptions, 'contentPathMap' | 'repoRoot'>): string;
+export declare function mapFilters(definition: SdkModelDefinition, filters?: SdkFilterCondition[]): {
+    field: string;
+    op: import("../sdk-types.js").SdkFilterOperator;
+    value: unknown;
+}[];
+export declare function mapSort(definition: SdkModelDefinition, sort?: SdkSortSpec[]): {
+    field: string;
+    direction?: "asc" | "desc";
+}[];
+export declare function entryFromTreeDxFile(definition: SdkModelDefinition, value: unknown, contentDir: string): SdkContentEntry;
+export declare class TreeDxRepositoryAdapter {
+    private readonly options;
+    constructor(options: TreeDxRepositoryAdapterOptions);
+    list(model: string): Promise<SdkContentEntry[]>;
+    get(request: SdkGetRequest): Promise<SdkContentEntry | null>;
+    search(request: SdkSearchRequest): Promise<SdkContentEntry[]>;
+    follow(request: SdkFollowRequest): Promise<{
+        items: SdkContentEntry[];
+        since: string;
+    }>;
+    pick(request: SdkPickRequest): Promise<SdkPickResult<SdkContentEntry>>;
+    create(request: SdkMutationRequest): Promise<TreeDxContentMutationResult>;
+    update(request: SdkUpdateRequest): Promise<TreeDxContentMutationResult>;
+    private writeAndCommit;
+}