@treeseed/sdk 0.10.27 → 0.11.0

package/dist/treedx/types.js

@@ -0,0 +1,8 @@
+function assertTreeDxOk(value, label = "TreeDX response") {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value.ok !== true) {
+    throw new Error(`${label} was not an ok TreeDX response.`);
+  }
+}
+export {
+  assertTreeDxOk
+};

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

@@ -0,0 +1,27 @@
+import { TreeDxClient } from './client.ts';
+import type { TreeDxCommitRequest, TreeDxCommitResult, TreeDxCreateWorkspaceRequest, TreeDxDiff, TreeDxExecRequest, TreeDxExecResult, TreeDxFile, TreeDxFileMutationResult, TreeDxListTreeRequest, TreeDxPatchFileRequest, TreeDxReadFileRequest, TreeDxSearchRequest, TreeDxSearchResult, TreeDxStatus, TreeDxTreeEntry, TreeDxWorkspace, TreeDxWriteFileRequest, TreeDxDeleteFileRequest } from './types.ts';
+export interface TreeDxWorkspaceAdapterOptions {
+    client: TreeDxClient;
+    repoId: string;
+    workspaceId?: string;
+}
+export declare class TreeDxWorkspaceAdapter {
+    private readonly options;
+    private workspaceId?;
+    constructor(options: TreeDxWorkspaceAdapterOptions);
+    create(input: TreeDxCreateWorkspaceRequest): Promise<TreeDxWorkspace>;
+    close(workspaceId?: string): Promise<void>;
+    listTree(path?: string): Promise<TreeDxTreeEntry[]>;
+    readFile(path: string): Promise<TreeDxFile>;
+    writeFile(path: string, content: string, options?: Omit<TreeDxWriteFileRequest, 'workspaceId' | 'path' | 'content'>): Promise<TreeDxFileMutationResult>;
+    patchFile(path: string, patch: string, options?: Omit<TreeDxPatchFileRequest, 'workspaceId' | 'path' | 'patch'>): Promise<TreeDxFileMutationResult>;
+    deleteFile(path: string, options?: Omit<TreeDxDeleteFileRequest, 'workspaceId' | 'path'>): Promise<TreeDxFileMutationResult>;
+    search(input: Omit<TreeDxSearchRequest, 'workspaceId'>): Promise<TreeDxSearchResult>;
+    status(): Promise<TreeDxStatus>;
+    diff(): Promise<TreeDxDiff>;
+    commit(input: Omit<TreeDxCommitRequest, 'workspaceId'>): Promise<TreeDxCommitResult>;
+    exec(input: Omit<TreeDxExecRequest, 'workspaceId'>): Promise<TreeDxExecResult>;
+    rawListTree(input: TreeDxListTreeRequest): Promise<TreeDxTreeEntry[]>;
+    rawReadFile(input: TreeDxReadFileRequest): Promise<TreeDxFile>;
+    private requireWorkspaceId;
+}

package/dist/treedx/workspace-adapter.js

@@ -0,0 +1,65 @@
+import { TreeDxApiError } from "./errors.js";
+class TreeDxWorkspaceAdapter {
+  constructor(options) {
+    this.options = options;
+    this.workspaceId = options.workspaceId;
+  }
+  options;
+  workspaceId;
+  async create(input) {
+    const workspace = await this.options.client.createWorkspace({ ...input, repoId: input.repoId ?? this.options.repoId });
+    this.workspaceId = workspace.workspaceId;
+    return workspace;
+  }
+  close(workspaceId = this.requireWorkspaceId()) {
+    return this.options.client.closeWorkspace(workspaceId);
+  }
+  listTree(path = "") {
+    return this.options.client.listTree({ workspaceId: this.requireWorkspaceId(), path });
+  }
+  readFile(path) {
+    return this.options.client.readFile({ workspaceId: this.requireWorkspaceId(), path });
+  }
+  writeFile(path, content, options = {}) {
+    return this.options.client.writeFile({ ...options, workspaceId: this.requireWorkspaceId(), path, content });
+  }
+  patchFile(path, patch, options = {}) {
+    return this.options.client.patchFile({ ...options, workspaceId: this.requireWorkspaceId(), path, patch });
+  }
+  deleteFile(path, options = {}) {
+    return this.options.client.deleteFile({ ...options, workspaceId: this.requireWorkspaceId(), path });
+  }
+  search(input) {
+    return this.options.client.search({ ...input, workspaceId: this.requireWorkspaceId() });
+  }
+  status() {
+    return this.options.client.status({ workspaceId: this.requireWorkspaceId() });
+  }
+  diff() {
+    return this.options.client.diff({ workspaceId: this.requireWorkspaceId() });
+  }
+  commit(input) {
+    return this.options.client.commit({ ...input, workspaceId: this.requireWorkspaceId() });
+  }
+  exec(input) {
+    return this.options.client.exec({ ...input, workspaceId: this.requireWorkspaceId() });
+  }
+  rawListTree(input) {
+    return this.options.client.listTree(input);
+  }
+  rawReadFile(input) {
+    return this.options.client.readFile(input);
+  }
+  requireWorkspaceId() {
+    if (!this.workspaceId) {
+      throw new TreeDxApiError("TreeDX workspace ID is required.", {
+        status: 400,
+        code: "workspace_required"
+      });
+    }
+    return this.workspaceId;
+  }
+}
+export {
+  TreeDxWorkspaceAdapter
+};

package/dist/treedx-backends.d.ts

@@ -0,0 +1,218 @@
+import { TreeDxApiError, TreeDxClient } from './treedx-client.ts';
+import { ContentStore } from './content-store.ts';
+import { ContentGraphRuntime } from './graph.ts';
+import type { SdkContentEntry, SdkContextPackRequest, SdkFollowRequest, SdkGetRequest, SdkGraphDslParseResult, SdkGraphQueryRequest, SdkGraphRefreshRequest, SdkModelRegistry, SdkMutationRequest, SdkPickRequest, SdkPickResult, SdkSearchRequest, SdkUpdateRequest } from './sdk-types.ts';
+export interface TreeSeedTreeDxRepositoryHint {
+    name?: string;
+    owner?: string;
+    remoteUrl?: string;
+    defaultBranch?: string;
+    purpose?: 'project_content' | 'site_code' | 'optional_project';
+    metadata?: Record<string, unknown>;
+}
+export interface TreeSeedTreeDxContentPathRule {
+    paths: string[];
+    repositoryHints?: TreeSeedTreeDxRepositoryHint[];
+}
+export interface AgentSdkTreeDxOptions {
+    enabled?: boolean;
+    baseUrl?: string;
+    token?: string;
+    repoId?: string;
+    ref?: string;
+    workspaceId?: string;
+    contentPathMap?: Record<string, string | TreeSeedTreeDxContentPathRule>;
+    repositoryHints?: TreeSeedTreeDxRepositoryHint[];
+    fetchImpl?: typeof fetch;
+}
+export interface AgentSdkContentRepositoryOptions {
+    adapter?: 'treedx' | 'local';
+}
+export interface ResolvedTreeDxOptions {
+    baseUrl: string;
+    token?: string;
+    repoId?: string;
+    ref?: string;
+    workspaceId?: string;
+    contentPathMap?: Record<string, string | TreeSeedTreeDxContentPathRule>;
+    repositoryHints: TreeSeedTreeDxRepositoryHint[];
+    fetchImpl?: typeof fetch;
+}
+export interface ContentBackend {
+    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<unknown>;
+    update(request: SdkUpdateRequest): Promise<unknown>;
+}
+export interface GraphBackend {
+    refresh(request?: SdkGraphRefreshRequest): Promise<unknown>;
+    queryGraph(request: SdkGraphQueryRequest): Promise<unknown>;
+    buildContextPack(request: SdkContextPackRequest): Promise<unknown>;
+    parseGraphDsl(source: string): Promise<SdkGraphDslParseResult>;
+}
+export interface ExecBackend {
+    run(input: unknown): Promise<unknown>;
+}
+export interface TreeDxRepositoryCandidate {
+    repoId: string;
+    ref?: string;
+    path: string;
+    repository: Record<string, unknown>;
+}
+export interface TreeDxPortfolioResolverOptions {
+    client: TreeDxClient;
+    repoId?: string;
+    ref?: string;
+    repositoryHints?: TreeSeedTreeDxRepositoryHint[];
+}
+export declare class TreeDxContentRepositoryConfigError extends Error {
+    constructor(message?: string);
+}
+export declare function resolveTreeDxOptions(input?: AgentSdkTreeDxOptions): ResolvedTreeDxOptions | null;
+export declare function createTreeDxClientFromAgentOptions(options: ResolvedTreeDxOptions): TreeDxClient;
+export declare class TreeDxPortfolioResolver {
+    private readonly options;
+    private repositoryCache;
+    private candidateCache;
+    constructor(options: TreeDxPortfolioResolverOptions);
+    listRepositories(): Promise<Record<string, unknown>[]>;
+    resolveCandidates(rule: TreeSeedTreeDxContentPathRule): Promise<TreeDxRepositoryCandidate[] | {
+        repoId: string;
+        ref: string | undefined;
+        path: string;
+        repository: {
+            repoId: string | undefined;
+        };
+    }[]>;
+    private resolveCandidatesUncached;
+}
+export declare class LocalContentBackend implements ContentBackend {
+    private readonly store;
+    constructor(store: ContentStore);
+    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<{
+        item: SdkContentEntry;
+        git: import("./git-runtime.ts").GitMutationResult;
+    }>;
+    update(request: SdkUpdateRequest): Promise<{
+        item: SdkContentEntry;
+        git: import("./git-runtime.ts").GitMutationResult;
+    }>;
+}
+export declare class MissingTreeDxContentBackend implements ContentBackend {
+    private fail;
+    list(): Promise<SdkContentEntry[]>;
+    get(): Promise<SdkContentEntry | null>;
+    search(): Promise<SdkContentEntry[]>;
+    follow(): Promise<{
+        items: SdkContentEntry[];
+        since: string;
+    }>;
+    pick(): Promise<SdkPickResult<SdkContentEntry>>;
+    create(): Promise<unknown>;
+    update(): Promise<unknown>;
+}
+export declare class TreeDxContentBackend implements ContentBackend {
+    private readonly options;
+    constructor(options: {
+        client: TreeDxClient;
+        repoRoot: string;
+        models: SdkModelRegistry;
+        resolver: TreeDxPortfolioResolver;
+        directRepoId?: string;
+        ref?: string;
+        workspaceId?: string;
+        contentPathMap?: Record<string, string | TreeSeedTreeDxContentPathRule>;
+        localLeaseStore: ContentStore;
+    });
+    private definition;
+    private pathRule;
+    private readEntry;
+    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>>;
+    private resolveWritePath;
+    private requireWorkspaceId;
+    private createDirectWorkspace;
+    private commitDirectWorkspace;
+    create(request: SdkMutationRequest): Promise<{
+        item: {
+            id: string;
+            slug: string;
+            model: import("./sdk-types.ts").SdkModelName;
+            title: string | undefined;
+            path: string;
+            body: string;
+            frontmatter: Record<string, unknown>;
+            createdAt: string | null;
+            updatedAt: string | null;
+        };
+        git: null;
+    }>;
+    update(request: SdkUpdateRequest): Promise<{
+        item: {
+            title: string | undefined;
+            body: string;
+            frontmatter: {
+                [x: string]: unknown;
+            };
+            updatedAt: string | null;
+            id: string;
+            slug: string;
+            model: import("./sdk-types.ts").SdkModelName;
+            path: string;
+            createdAt: string | null;
+        };
+        git: null;
+    }>;
+}
+export declare class LocalGraphBackend implements GraphBackend {
+    private readonly runtime;
+    constructor(runtime: ContentGraphRuntime);
+    refresh(request?: SdkGraphRefreshRequest): Promise<import("./sdk-types.ts").SdkGraphRefreshPayload>;
+    queryGraph(request: SdkGraphQueryRequest): Promise<import("./sdk-types.ts").SdkGraphQueryResult>;
+    buildContextPack(request: SdkContextPackRequest): Promise<import("./sdk-types.ts").SdkContextPack>;
+    parseGraphDsl(source: string): Promise<SdkGraphDslParseResult>;
+}
+export declare class TreeDxGraphBackend implements GraphBackend {
+    private readonly options;
+    constructor(options: {
+        client: TreeDxClient;
+        resolver: TreeDxPortfolioResolver;
+        localRuntime: ContentGraphRuntime;
+        ref?: string;
+    });
+    refresh(request?: SdkGraphRefreshRequest): Promise<unknown[]>;
+    private repoIds;
+    queryGraph(request: SdkGraphQueryRequest): Promise<unknown>;
+    buildContextPack(request: SdkContextPackRequest): Promise<unknown>;
+    parseGraphDsl(source: string): Promise<SdkGraphDslParseResult>;
+}
+export declare class LocalExecBackend implements ExecBackend {
+    run(input: unknown): Promise<unknown>;
+}
+export declare class TreeDxExecBackend implements ExecBackend {
+    private readonly client;
+    private readonly workspaceId?;
+    constructor(client: TreeDxClient, workspaceId?: string | undefined);
+    run(input: unknown): Promise<unknown>;
+}
+export { TreeDxApiError };