@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/treedx/types/tree-dx-context-request.d.ts

@@ -0,0 +1,245 @@
+import type { SdkContextPack, SdkContextPackRequest, SdkGraphDslParseResult } from '../../entrypoints/models/sdk-types.js';
+import { TreeDxMirror } from './tree-dx-actor.js';
+import { TreeDxContextBudgetDiagnostics, TreeDxContextMode } from './tree-dx-exec-result.js';
+export interface TreeDxContextRequest extends SdkContextPackRequest {
+    repoId?: string;
+    ref?: string;
+    mode?: TreeDxContextMode;
+}
+export type TreeDxContextResult = SdkContextPack & {
+    repoId: string;
+    graphVersion: string;
+    mode?: TreeDxContextMode;
+    diagnostics?: {
+        mode?: TreeDxContextMode;
+        budget?: TreeDxContextBudgetDiagnostics;
+        provenancePaths?: string[];
+        [key: string]: unknown;
+    };
+};
+export interface TreeDxCtxParseRequest {
+    repoId?: string;
+    ref?: string;
+    source: string;
+}
+export type TreeDxCtxParseResult = SdkGraphDslParseResult;
+export interface TreeDxFederatedScopeInput {
+    repoIds?: string[];
+    refs?: Record<string, string>;
+    paths?: Record<string, string[]>;
+    includeErrors?: boolean;
+    timeoutMs?: number;
+    limit?: number;
+    cursor?: string | null;
+}
+export interface TreeDxFederatedError {
+    repoId?: string;
+    nodeId?: string;
+    code: string;
+    message: string;
+    status?: number;
+}
+export interface TreeDxFederatedDiagnostics {
+    requestedRepoCount: number;
+    executedRepoCount: number;
+    rejectedRepoCount: number;
+    partialFailureCount: number;
+    routing: Array<{
+        repoId?: string;
+        nodeId?: string;
+        source: 'local' | 'remote';
+        status: 'ok' | 'rejected' | 'partial_failure';
+        error?: {
+            code: string;
+        };
+    }>;
+}
+export interface TreeDxFederatedSearchRequest extends TreeDxFederatedScopeInput {
+    repoId?: string;
+    query: string;
+    filters?: unknown[];
+    sort?: Array<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>;
+}
+export interface TreeDxFederatedSearchResult {
+    query: string;
+    results: Array<Record<string, unknown> & {
+        repoId: string;
+        ref: string;
+        source: 'local' | 'remote';
+    }>;
+    page: {
+        limit: number;
+        hasMore: boolean;
+        cursor?: string | null;
+    };
+    diagnostics: TreeDxFederatedDiagnostics;
+    errors?: TreeDxFederatedError[];
+}
+export interface TreeDxFederatedQueryRequest extends TreeDxFederatedScopeInput {
+    repoId?: string;
+    type: 'path' | 'text' | 'frontmatter' | 'section' | 'link' | 'changed_path' | 'combined';
+    query?: string;
+    filters?: unknown[];
+    sort?: Array<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>;
+}
+export interface TreeDxFederatedQueryResult {
+    type: string;
+    results: Array<Record<string, unknown> & {
+        repoId: string;
+        ref: string;
+        source: 'local' | 'remote';
+    }>;
+    page: {
+        limit: number;
+        hasMore: boolean;
+        cursor?: string | null;
+    };
+    diagnostics: TreeDxFederatedDiagnostics;
+    errors?: TreeDxFederatedError[];
+}
+export interface TreeDxFederatedContextRequest extends TreeDxFederatedScopeInput {
+    query?: string;
+    seedIds?: string[];
+    seeds?: unknown[];
+    relations?: unknown[];
+    scopePaths?: string[];
+    budget?: Record<string, unknown>;
+}
+export interface TreeDxFederatedContextResult {
+    nodes: unknown[];
+    edges: unknown[];
+    files?: unknown[];
+    sections?: unknown[];
+    diagnostics: TreeDxFederatedDiagnostics & Record<string, unknown>;
+    errors?: TreeDxFederatedError[];
+}
+export interface TreeDxFederatedGraphRequest extends TreeDxFederatedScopeInput {
+    query?: string;
+    seedIds?: string[];
+    seeds?: unknown[];
+    relations?: unknown[];
+    scopePaths?: string[];
+    options?: Record<string, unknown>;
+}
+export interface TreeDxFederatedGraphResult {
+    nodes: unknown[];
+    edges: unknown[];
+    diagnostics: TreeDxFederatedDiagnostics & {
+        crossRepoEdgeCount?: number;
+    };
+    errors?: TreeDxFederatedError[];
+}
+export type TreeDxSnapshotKind = 'repository_snapshot' | 'index_snapshot' | 'graph_snapshot' | 'search_snapshot' | 'audit_export';
+export interface TreeDxSnapshotFile {
+    path: string;
+    objectId: string;
+    size: number;
+    contentHash: string;
+}
+export interface TreeDxArtifact {
+    artifactId: string;
+    snapshotId: string;
+    repoId: string;
+    format: 'tar.zst';
+    size: number;
+    checksum: string;
+    uri: string;
+    downloadUrl?: string;
+    createdAt?: string;
+    status?: string;
+}
+export interface TreeDxArtifactListRequest {
+    repoId?: string;
+}
+export interface TreeDxArtifactGetRequest {
+    repoId?: string;
+    artifactId: string;
+}
+export interface TreeDxArtifactDeleteRequest {
+    repoId?: string;
+    artifactId: string;
+}
+export interface TreeDxArtifactCleanupRequest {
+    retentionDays?: number;
+}
+export interface TreeDxArtifactCleanupResult {
+    deletedCount: number;
+    retentionDays: number;
+    workspaces?: {
+        expiredWorkspaceIds: string[];
+        releasedLeaseIds: string[];
+    };
+}
+export interface TreeDxSnapshot {
+    snapshotId: string;
+    repoId: string;
+    ref: string;
+    commitSha: string;
+    kind: TreeDxSnapshotKind;
+    includedPaths: string[];
+    graphVersion?: string | null;
+    fileCount: number;
+    totalBytes: number;
+    files?: TreeDxSnapshotFile[];
+    checksums: Record<string, unknown>;
+    artifact?: TreeDxArtifact | null;
+    createdAt: string;
+}
+export interface TreeDxSnapshotBuildRequest {
+    repoId?: string;
+    ref?: string;
+    kind?: TreeDxSnapshotKind;
+    paths?: string[];
+    allowProtected?: boolean;
+    includeGraph?: boolean;
+}
+export interface TreeDxArtifactExportRequest extends TreeDxSnapshotBuildRequest {
+    snapshotId?: string;
+}
+export interface TreeDxArtifactDownload {
+    content: ArrayBuffer;
+    contentType: string | null;
+    filename?: string;
+    checksum?: string;
+    snapshotId?: string;
+}
+export interface TreeDxMirrorSyncRequest {
+    repoId?: string;
+    mirrorId: string;
+    remoteName?: string;
+    remoteUrl?: string;
+    credentialId?: string;
+    refspecs?: string[];
+    planOnly?: boolean;
+}
+export interface TreeDxMirrorSyncResult {
+    mirror: TreeDxMirror;
+    sync: Record<string, unknown>;
+}
+export interface TreeDxFetchRemoteRequest {
+    repoId?: string;
+    remoteName?: string;
+    remoteUrl?: string;
+    credentialId?: string;
+    refspecs?: string[];
+    planOnly?: boolean;
+}
+export interface TreeDxFetchRemoteResult {
+    fetch: {
+        repoId?: string;
+        remoteName: string;
+        remoteUrl?: string | null;
+        refspecs: string[];
+        updatedRefs: string[];
+        receivedPack?: boolean;
+        beforeHead?: string | null;
+        afterHead?: string | null;
+        status: string;
+    };
+}

package/dist/treedx/types/tree-dx-exec-result.d.ts

@@ -0,0 +1,249 @@
+import type { SdkGraphQueryRequest, SdkGraphQueryResult, SdkGraphRefreshPayload, SdkGraphRefreshRequest, SdkGraphSearchOptions } from '../../entrypoints/models/sdk-types.js';
+export interface TreeDxExecResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    elapsedMs: number;
+    truncated: boolean;
+    changedPaths: string[];
+    sandbox?: {
+        backend: 'direct_dev' | 'container_sandbox' | 'external_worker' | string;
+        network: string;
+        resourceLimits?: {
+            cpu?: number;
+            memoryMb?: number;
+            pids?: number;
+        };
+        isolated: boolean;
+    };
+}
+export interface TreeDxRepositoryReadRequest {
+    repoId?: string;
+    ref?: string;
+    path?: string;
+    paths?: string[];
+    encoding?: 'utf8' | 'base64';
+    parseFrontmatter?: boolean;
+    allowProtected?: boolean;
+    /** Bounds encoded content returned by a single-path read. Maximum 196,608 bytes. */
+    maxBytes?: number;
+    /** Resumes a bounded read at a server-returned UTF-8 byte boundary. */
+    offsetBytes?: number;
+}
+export interface TreeDxRepositoryPathsRequest {
+    repoId?: string;
+    ref?: string;
+    paths?: string[];
+    kinds?: Array<'blob' | 'tree'>;
+    extensions?: string[];
+    limit?: number;
+    cursor?: string | null;
+    allowProtected?: boolean;
+}
+export interface TreeDxRepositorySearchRequest {
+    repoId?: string;
+    ref?: string;
+    paths?: string[];
+    query: string;
+    filters?: Array<{
+        field: string;
+        op: string;
+        value: unknown;
+    }>;
+    sort?: Array<{
+        field: string;
+        direction?: 'asc' | 'desc';
+    }>;
+    limit?: number;
+    cursor?: string | null;
+    caseSensitive?: boolean;
+    includeBody?: boolean;
+    includeFrontmatter?: boolean;
+    allowProtected?: boolean;
+    includeDiagnostics?: boolean;
+    diagnosticsLevel?: 'none' | 'summary' | 'ranking';
+}
+export interface TreeDxRepositoryQueryRequest {
+    repoId?: string;
+    ref?: string;
+    type?: 'path' | 'text' | 'frontmatter' | 'section' | 'link' | 'changed_path' | 'combined';
+    paths?: string[];
+    path?: string;
+    query?: string;
+    filters?: Array<{
+        field: string;
+        op: string;
+        value: unknown;
+    }>;
+    sort?: Array<{
+        field: string;
+        direction?: 'asc' | 'desc';
+    }>;
+    limit?: number;
+    cursor?: string | null;
+    baseRef?: string;
+    allowProtected?: boolean;
+    includeBody?: boolean;
+    includeFrontmatter?: boolean;
+    parseFrontmatter?: boolean;
+    encoding?: 'utf8' | 'base64';
+    includeDiagnostics?: boolean;
+    diagnosticsLevel?: 'none' | 'summary' | 'ranking';
+}
+export interface TreeDxRankingDiagnostics {
+    level: 'none' | 'summary' | 'ranking';
+    authorizedResultCount: number;
+    returnedResultCount: number;
+    searchedPatterns?: string[];
+    scoreFactors?: unknown;
+}
+export interface TreeDxRepositoryQueryResult {
+    repoId: string;
+    ref: string;
+    resolvedRef: string;
+    query?: string;
+    results?: unknown[];
+    entries?: unknown[];
+    file?: unknown;
+    files?: unknown[];
+    diagnostics?: TreeDxRankingDiagnostics;
+    page?: {
+        limit: number;
+        nextCursor: string | null;
+        hasMore: boolean;
+    };
+}
+export interface TreeDxGraphRefreshRequest extends SdkGraphRefreshRequest {
+    repoId?: string;
+    ref?: string;
+    allowProtected?: boolean;
+    force?: boolean;
+    incremental?: boolean;
+    changedPaths?: string[];
+    baseGraphVersion?: string;
+    forceFull?: boolean;
+}
+export type TreeDxGraphRefreshResult = SdkGraphRefreshPayload & {
+    repoId: string;
+    ref: string;
+    resolvedRef: string;
+    graphVersion: string;
+    jobId?: string;
+    refreshMode?: 'full' | 'incremental';
+    fallbackReason?: string | null;
+    changedPathCount?: number;
+    indexedPathCount?: number;
+    removedPathCount?: number;
+    stale?: boolean;
+};
+export interface TreeDxGraphRefreshJobRequest {
+    repoId?: string;
+    ref?: string;
+    jobId: string;
+}
+export interface TreeDxGraphRefreshJob {
+    jobId: string;
+    repoId: string;
+    ref: string;
+    requestedPaths: string[];
+    changedPaths: string[];
+    baseGraphVersion?: string | null;
+    graphVersion?: string | null;
+    refreshMode: 'full' | 'incremental';
+    fallbackReason?: string | null;
+    stale: boolean;
+    status: 'running' | 'completed' | 'failed';
+    startedAt: string;
+    completedAt?: string | null;
+    indexedPathCount: number;
+    removedPathCount: number;
+    errorCode?: string | null;
+}
+export type TreeDxContextMode = 'brief' | 'detailed' | 'citations' | 'mixed';
+export interface TreeDxContextBudgetDiagnostics {
+    requestedMaxNodes: number;
+    usedNodes: number;
+    requestedMaxTokens: number;
+    estimatedTokens: number;
+    truncated: boolean;
+}
+export interface TreeDxSearchIndexRefreshRequest {
+    repoId?: string;
+    ref?: string;
+    paths?: string[];
+    allowProtected?: boolean;
+}
+export interface TreeDxSearchIndexRefreshResult {
+    repoId: string;
+    ref: string;
+    resolvedRef: string;
+    indexVersion: string;
+    graphVersion?: string | null;
+    segmentIds: string[];
+    indexedPathCount: number;
+    sourceCommit?: string | null;
+    stale: boolean;
+}
+export interface TreeDxSearchIndexStatusRequest {
+    repoId?: string;
+    ref?: string;
+}
+export interface TreeDxSearchIndexStatus {
+    repoId: string;
+    ref: string;
+    resolvedRef: string;
+    ready: boolean;
+    indexVersion?: string | null;
+    graphVersion?: string | null;
+    segmentIds: string[];
+    indexedPathCount: number;
+    segmentCount: number;
+    sourceCommit?: string | null;
+    stale: boolean;
+}
+export interface TreeDxSearchIndexCompactRequest {
+    repoId?: string;
+    ref?: string;
+    planOnly?: boolean;
+}
+export interface TreeDxSearchIndexCompactResult {
+    repoId: string;
+    ref: string;
+    planOnly: boolean;
+    segmentsBefore: number;
+    segmentsAfter: number;
+    compacted: boolean;
+}
+export interface TreeDxGraphSearchRequest {
+    repoId?: string;
+    ref?: string;
+    query: string;
+    limit?: number;
+    options?: SdkGraphSearchOptions;
+}
+export interface TreeDxGraphNodeRequest {
+    repoId?: string;
+    ref?: string;
+    nodeId: string;
+}
+export interface TreeDxGraphRelatedRequest {
+    repoId?: string;
+    ref?: string;
+    nodeId: string;
+    relations?: string[];
+    options?: Record<string, unknown>;
+}
+export interface TreeDxGraphSubgraphRequest {
+    repoId?: string;
+    ref?: string;
+    seedIds: string[];
+    options?: Record<string, unknown>;
+}
+export interface TreeDxGraphQueryRequest extends SdkGraphQueryRequest {
+    repoId?: string;
+    ref?: string;
+}
+export type TreeDxGraphQueryResult = SdkGraphQueryResult & {
+    repoId: string;
+    graphVersion: string;
+};

package/dist/treedx/types/tree-dx-list-tree-request.d.ts

@@ -0,0 +1,222 @@
+import { TreeDxWorkspaceRequest } from './tree-dx-actor.js';
+export interface TreeDxListTreeRequest extends TreeDxWorkspaceRequest {
+    path?: string;
+    includeDeleted?: boolean;
+}
+export interface TreeDxTreeEntry {
+    path: string;
+    name: string;
+    kind: 'blob' | 'tree';
+    status?: string;
+    source?: 'base' | 'overlay';
+    objectId?: string | null;
+    contentHash?: string | null;
+}
+export interface TreeDxReadFileRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxFile {
+    path: string;
+    encoding: 'utf8' | 'base64';
+    content: string;
+    sha: string;
+    source: 'base' | 'overlay';
+    stat?: {
+        size: number;
+        mtime?: string | null;
+    };
+}
+export interface TreeDxWriteFileRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    encoding?: 'utf8';
+    content: string;
+    expectedSha?: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxWriteFilesRequest extends TreeDxWorkspaceRequest {
+    files: Array<Omit<TreeDxWriteFileRequest, 'workspaceId'>>;
+}
+export interface TreeDxWriteFilesResult {
+    files: TreeDxFileMutationResult[];
+}
+export interface TreeDxPatchFileRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    patch: string;
+    expectedSha?: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxDeleteFileRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    expectedSha?: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxFileMutationResult {
+    path: string;
+    status?: string;
+    file?: {
+        path: string;
+        encoding?: string;
+        sha?: string;
+        size?: number;
+        source?: string;
+    };
+}
+export interface TreeDxBlobReadRequest {
+    repoId?: string;
+    ref?: string;
+    path: string;
+    encoding?: 'base64';
+    expectedContentHash?: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxBlobWriteRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    encoding?: 'base64';
+    contentBase64: string;
+    contentType?: string;
+    expectedSha?: string;
+    expectedContentHash?: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxBlobDeleteRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    expectedSha?: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxBlobDownloadRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxBlobUploadRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    content: ArrayBuffer | Uint8Array | Blob;
+    contentType?: string;
+    expectedSha?: string;
+    expectedContentHash?: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxBlob {
+    path: string;
+    encoding: 'base64';
+    contentBase64: string;
+    objectId?: string | null;
+    sha?: string | null;
+    contentHash: string;
+    byteLength: number;
+    contentType: string;
+    source: 'base' | 'workspace';
+}
+export interface TreeDxBlobMutationResult {
+    workspaceId: string;
+    path: string;
+    op: 'put' | 'delete';
+    encoding?: 'base64';
+    contentHash?: string | null;
+    byteLength?: number;
+    contentType?: string | null;
+}
+export interface TreeDxBlobDownload {
+    content: ArrayBuffer;
+    contentType: string | null;
+    contentHash?: string;
+    objectId?: string;
+    source?: 'base' | 'workspace';
+}
+export interface TreeDxBlobUploadSession {
+    uploadId: string;
+    workspaceId: string;
+    path: string;
+    contentType?: string | null;
+    expectedContentHash?: string | null;
+    expectedSha?: string | null;
+    createdAt: string;
+    expiresAt: string;
+    status: 'open' | 'completed' | 'aborted' | string;
+}
+export interface TreeDxBlobUploadCreateRequest extends TreeDxWorkspaceRequest {
+    path: string;
+    contentType?: string;
+    expectedSha?: string;
+    expectedContentHash?: string;
+    allowProtected?: boolean;
+}
+export interface TreeDxBlobUploadPartRequest extends TreeDxWorkspaceRequest {
+    uploadId: string;
+    partNumber: number;
+    content: ArrayBuffer | Uint8Array | Blob;
+}
+export interface TreeDxBlobUploadCompleteRequest extends TreeDxWorkspaceRequest {
+    uploadId: string;
+    expectedSha?: string;
+    expectedContentHash?: string;
+    allowProtected?: boolean;
+    contentType?: string;
+}
+export interface TreeDxBlobUploadAbortRequest extends TreeDxWorkspaceRequest {
+    uploadId: string;
+}
+export interface TreeDxBlobUploadPart {
+    uploadId: string;
+    workspaceId: string;
+    partNumber: number;
+    byteLength: number;
+    contentHash: string;
+    createdAt: string;
+}
+export interface TreeDxSearchRequest extends TreeDxWorkspaceRequest {
+    query: string;
+    path?: string;
+    limit?: number;
+    caseSensitive?: boolean;
+}
+export interface TreeDxSearchResult {
+    results: Array<{
+        path: string;
+        line: number;
+        column: number;
+        snippet: string;
+        source: 'base' | 'overlay';
+    }>;
+    truncated?: boolean;
+}
+export interface TreeDxStatus {
+    workspaceId: string;
+    status: string;
+    branchName?: string;
+    commitSha?: string;
+    changes: Array<Record<string, unknown>>;
+}
+export interface TreeDxDiff {
+    workspaceId: string;
+    diff: string;
+    changedPaths: string[];
+}
+export interface TreeDxCommitRequest extends TreeDxWorkspaceRequest {
+    message: string;
+    author: {
+        name: string;
+        email: string;
+    };
+    indexPolicy?: string;
+}
+export interface TreeDxCommitResult {
+    repoId: string;
+    workspaceId: string;
+    branchName: string;
+    commitSha: string;
+    changedPaths: string[];
+    status: 'committed';
+}
+export interface TreeDxExecRequest extends TreeDxWorkspaceRequest {
+    cmd: string;
+    mode?: 'read_only' | 'verification' | 'write_limited';
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+    network?: 'none' | 'host';
+    resourceLimits?: {
+        cpu?: number;
+        memoryMb?: number;
+        pids?: number;
+    };
+}