@inkeep/agents-core 0.41.2 → 0.42.0

package/dist/dolt/branch.js

@@ -0,0 +1,82 @@
+import { doltHashOf } from "./commit.js";
+import { resolveRef } from "./ref-helpers.js";
+import { sql } from "drizzle-orm";
+import { logger } from "@composio/core";
+
+//#region src/dolt/branch.ts
+/**
+* Create a new branch
+*/
+const doltBranch = (db) => async (params) => {
+	if (params.startPoint) {
+		const startPointHash = await doltHashOf(db)({ revision: params.startPoint });
+		await db.execute(sql.raw(`SELECT DOLT_BRANCH('${params.name}', '${startPointHash}')`));
+	} else await db.execute(sql.raw(`SELECT DOLT_BRANCH('${params.name}')`));
+};
+/**
+* Delete a branch
+*/
+const doltDeleteBranch = (db) => async (params) => {
+	const flag = params.force ? "-D" : "-d";
+	await db.execute(sql.raw(`SELECT DOLT_BRANCH('${flag}', '${params.name}')`));
+};
+/**
+* Rename a branch
+*/
+const doltRenameBranch = (db) => async (params) => {
+	await db.execute(sql.raw(`SELECT DOLT_BRANCH('-m', '${params.oldName}', '${params.newName}')`));
+};
+/**
+* List all branches
+*/
+const doltListBranches = (db) => async () => {
+	return (await db.execute(sql`SELECT * FROM dolt_branches`)).rows;
+};
+/**
+* Check if a branch exists
+*/
+const doltBranchExists = (db) => async (params) => {
+	return (await db.execute(sql.raw(`SELECT * FROM dolt_branches WHERE name = '${params.name}'`))).rows.length > 0;
+};
+/**
+* Checkout a branch or create and checkout a new branch
+*/
+const doltCheckout = (db) => async (params) => {
+	params.create ? await db.execute(sql.raw(`SELECT DOLT_CHECKOUT('-b', '${params.branch}')`)) : await db.execute(sql.raw(`SELECT DOLT_CHECKOUT('${params.branch}')`));
+};
+/**
+* Get the currently active branch
+*/
+const doltActiveBranch = (db) => async () => {
+	return (await db.execute(sql`SELECT ACTIVE_BRANCH() as branch`)).rows[0]?.branch;
+};
+const doltGetBranchNamespace = (scopes) => () => {
+	return `${scopes.tenantId}_${scopes.projectId}_${scopes.branchName}`;
+};
+/**
+* Create a branch if it doesn't exist, handling race conditions gracefully.
+* If multiple concurrent requests try to create the same branch, only one will succeed.
+*/
+const ensureBranchExists = async (db, branchName) => {
+	if (await resolveRef(db)(branchName)) {
+		logger.debug({ branchName }, "Branch already exists, skipping creation");
+		return;
+	}
+	try {
+		await doltBranch(db)({ name: branchName });
+		logger.debug({ branchName }, "Branch created successfully");
+	} catch (error) {
+		if (await resolveRef(db)(branchName)) {
+			logger.debug({ branchName }, "Branch creation failed but branch exists (concurrent creation), continuing");
+			return;
+		}
+		logger.error({
+			branchName,
+			error
+		}, "Branch creation failed and branch does not exist");
+		throw error;
+	}
+};
+
+//#endregion
+export { doltActiveBranch, doltBranch, doltBranchExists, doltCheckout, doltDeleteBranch, doltGetBranchNamespace, doltListBranches, doltRenameBranch, ensureBranchExists };

package/dist/dolt/branches-api.d.ts

@@ -0,0 +1,108 @@
+import { BranchInfo } from "../validation/dolt-schemas.js";
+import { AgentScopeConfig, ProjectScopeConfig } from "../types/utility.js";
+import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
+
+//#region src/dolt/branches-api.d.ts
+declare const MAIN_BRANCH_SUFFIX = "main";
+/**
+ * Get the tenant-scoped main branch name
+ */
+declare const getTenantMainBranch: (tenantId: string) => string;
+/**
+ * Check if a branch name (without tenant/project prefix) is a protected branch
+ */
+declare const isProtectedBranchName: (branchName: string) => boolean;
+type CreateBranchParams = {
+  tenantId: string;
+  projectId: string;
+  name: string;
+  /** Branch to create from. Defaults to tenant main branch. */
+  from?: string;
+  /**
+   * Whether to sync schema on the source branch before creating.
+   * This ensures the new branch starts with the latest schema from main.
+   * Default: true
+   */
+  syncSchemaOnSource?: boolean;
+};
+type DeleteBranchParams = {
+  tenantId: string;
+  projectId: string;
+  name: string;
+};
+type GetBranchParams = {
+  tenantId: string;
+  projectId: string;
+  name: string;
+};
+/**
+ * Parameters for checking out a branch with optional schema sync
+ */
+type CheckoutBranchParams = {
+  /** The full branch name (e.g., "tenant1_project1_main") */
+  branchName: string;
+  /** Whether to sync schema from main after checkout. Default: true */
+  syncSchema?: boolean;
+  /** Whether to auto-commit pending changes before schema sync. Default: false */
+  autoCommitPending?: boolean;
+};
+/**
+ * Result of a branch checkout operation
+ */
+type CheckoutBranchResult = {
+  /** The full branch name that was checked out */
+  branchName: string;
+  /** The commit hash of the branch after checkout (and potential schema sync) */
+  hash: string;
+  /** Result of the schema sync operation */
+  schemaSync: {
+    /** Whether schema sync was performed */
+    performed: boolean;
+    /** Whether there were schema differences */
+    hadDifferences: boolean;
+    /** Error message if schema sync failed */
+    error?: string;
+    /** The merge commit hash if schema was synced */
+    mergeCommitHash?: string;
+  };
+};
+/**
+ * Checkout a branch with optional schema synchronization from main.
+ *
+ * This function:
+ * 1. Checks out the specified branch
+ * 2. If syncSchema is true (default), checks for schema differences from main
+ * 3. If differences exist, merges schema from main into the branch
+ *
+ * @param db - Database client
+ * @returns Function that takes checkout params and returns checkout result
+ */
+declare const checkoutBranch: (db: AgentsManageDatabaseClient) => (params: CheckoutBranchParams) => Promise<CheckoutBranchResult>;
+/**
+ * Create a new branch with optional schema synchronization.
+ *
+ * This function:
+ * 1. Optionally syncs schema on the source branch from main (default: true)
+ * 2. Creates a new branch from the source branch
+ *
+ * By syncing schema on the source branch first, we ensure the new branch
+ * starts with the latest schema, avoiding schema conflicts later.
+ */
+declare const createBranch: (db: AgentsManageDatabaseClient) => (params: CreateBranchParams) => Promise<BranchInfo>;
+/**
+ * Delete a branch
+ */
+declare const deleteBranch: (db: AgentsManageDatabaseClient) => (params: DeleteBranchParams) => Promise<void>;
+/**
+ * Get a single branch
+ */
+declare const getBranch: (db: AgentsManageDatabaseClient) => (params: GetBranchParams) => Promise<BranchInfo | null>;
+/**
+ * List all branches for a project
+ * Returns only project-specific branches (e.g., {tenantId}_{projectId}_main, {tenantId}_{projectId}_feature-x)
+ * Does NOT include the tenant_main branch as that's an organizational branch, not a project development branch
+ */
+declare const listBranches: (db: AgentsManageDatabaseClient) => (params: ProjectScopeConfig) => Promise<BranchInfo[]>;
+declare const listBranchesForAgent: (db: AgentsManageDatabaseClient) => (params: AgentScopeConfig) => Promise<BranchInfo[]>;
+//#endregion
+export { CheckoutBranchParams, CheckoutBranchResult, CreateBranchParams, DeleteBranchParams, GetBranchParams, MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTenantMainBranch, isProtectedBranchName, listBranches, listBranchesForAgent };

package/dist/dolt/branches-api.js

@@ -0,0 +1,162 @@
+import { SCHEMA_SOURCE_BRANCH, ensureSchemaSync, getSchemaDiff, syncSchemaFromMain } from "./schema-sync.js";
+import { doltBranch, doltCheckout, doltDeleteBranch, doltGetBranchNamespace, doltListBranches } from "./branch.js";
+import { sql } from "drizzle-orm";
+
+//#region src/dolt/branches-api.ts
+const MAIN_BRANCH_SUFFIX = "main";
+/**
+* Get the tenant-scoped main branch name
+*/
+const getTenantMainBranch = (tenantId) => `${tenantId}_${MAIN_BRANCH_SUFFIX}`;
+/**
+* Check if a branch name (without tenant/project prefix) is a protected branch
+*/
+const isProtectedBranchName = (branchName) => {
+	return branchName === MAIN_BRANCH_SUFFIX;
+};
+/**
+* Checkout a branch with optional schema synchronization from main.
+*
+* This function:
+* 1. Checks out the specified branch
+* 2. If syncSchema is true (default), checks for schema differences from main
+* 3. If differences exist, merges schema from main into the branch
+*
+* @param db - Database client
+* @returns Function that takes checkout params and returns checkout result
+*/
+const checkoutBranch = (db) => async (params) => {
+	const { branchName, syncSchema = true, autoCommitPending = false } = params;
+	const branch = (await doltListBranches(db)()).find((b) => b.name === branchName);
+	if (!branch) throw new Error(`Branch '${branchName}' not found`);
+	await doltCheckout(db)({ branch: branchName });
+	let schemaSyncResult = {
+		synced: false,
+		hadDifferences: false
+	};
+	if (syncSchema && branchName !== SCHEMA_SOURCE_BRANCH) schemaSyncResult = await ensureSchemaSync(db)({
+		autoSync: true,
+		autoCommitPending
+	});
+	return {
+		branchName,
+		hash: (await doltListBranches(db)()).find((b) => b.name === branchName)?.hash ?? branch.hash,
+		schemaSync: {
+			performed: schemaSyncResult.synced,
+			hadDifferences: schemaSyncResult.hadDifferences,
+			error: schemaSyncResult.error,
+			mergeCommitHash: schemaSyncResult.mergeCommitHash
+		}
+	};
+};
+/**
+* Create a new branch with optional schema synchronization.
+*
+* This function:
+* 1. Optionally syncs schema on the source branch from main (default: true)
+* 2. Creates a new branch from the source branch
+*
+* By syncing schema on the source branch first, we ensure the new branch
+* starts with the latest schema, avoiding schema conflicts later.
+*/
+const createBranch = (db) => async (params) => {
+	const { tenantId, projectId, name, from, syncSchemaOnSource = true } = params;
+	if (!name || name.trim() === "") throw new Error("Branch name cannot be empty");
+	const fullName = doltGetBranchNamespace({
+		tenantId,
+		projectId,
+		branchName: name
+	})();
+	if ((await doltListBranches(db)()).some((b) => b.name === fullName)) throw new Error(`Branch '${name}' already exists`);
+	let fromFullBranchName;
+	if (from && from !== MAIN_BRANCH_SUFFIX) fromFullBranchName = doltGetBranchNamespace({
+		tenantId,
+		projectId,
+		branchName: from
+	})();
+	else fromFullBranchName = getTenantMainBranch(tenantId);
+	if (syncSchemaOnSource && fromFullBranchName !== SCHEMA_SOURCE_BRANCH) {
+		if ((await getSchemaDiff(db)(fromFullBranchName)).length > 0) {
+			await doltCheckout(db)({ branch: fromFullBranchName });
+			const syncResult = await syncSchemaFromMain(db)({ autoCommitPending: true });
+			if (syncResult.error && !syncResult.synced) throw new Error(`Failed to sync schema on source branch '${fromFullBranchName}': ${syncResult.error}`);
+		}
+	}
+	await doltBranch(db)({
+		name: fullName,
+		startPoint: fromFullBranchName
+	});
+	const newBranch = (await doltListBranches(db)()).find((b) => b.name === fullName);
+	if (!newBranch) throw new Error("Failed to create branch");
+	return {
+		baseName: name,
+		fullName,
+		hash: newBranch.hash
+	};
+};
+/**
+* Delete a branch
+*/
+const deleteBranch = (db) => async (params) => {
+	const { tenantId, projectId, name } = params;
+	if (isProtectedBranchName(name)) throw new Error(`Cannot delete protected branch '${name}'`);
+	const fullName = doltGetBranchNamespace({
+		tenantId,
+		projectId,
+		branchName: name
+	})();
+	if (!(await doltListBranches(db)()).some((b) => b.name === fullName)) throw new Error(`Branch '${name}' not found`);
+	await doltDeleteBranch(db)({ name: fullName });
+};
+/**
+* Get a single branch
+*/
+const getBranch = (db) => async (params) => {
+	const { tenantId, projectId, name } = params;
+	const fullName = doltGetBranchNamespace({
+		tenantId,
+		projectId,
+		branchName: name
+	})();
+	const branch = (await doltListBranches(db)()).find((b) => b.name === fullName);
+	if (!branch) return null;
+	return {
+		baseName: name,
+		fullName,
+		hash: branch.hash
+	};
+};
+/**
+* List all branches for a project
+* Returns only project-specific branches (e.g., {tenantId}_{projectId}_main, {tenantId}_{projectId}_feature-x)
+* Does NOT include the tenant_main branch as that's an organizational branch, not a project development branch
+*/
+const listBranches = (db) => async (params) => {
+	const { tenantId, projectId } = params;
+	const allBranches = await doltListBranches(db)();
+	const prefix = `${tenantId}_${projectId}_`;
+	return allBranches.filter((b) => b.name.startsWith(prefix)).map((b) => ({
+		baseName: b.name.substring(prefix.length),
+		fullName: b.name,
+		hash: b.hash
+	}));
+};
+const listBranchesForAgent = (db) => async (params) => {
+	const { tenantId, projectId, agentId } = params;
+	const allBranches = await listBranches(db)({
+		tenantId,
+		projectId
+	});
+	const branches = [];
+	for (const branch of allBranches) try {
+		const result = await db.execute(sql.raw(`SELECT id FROM agent AS OF '${branch.fullName}' WHERE id = '${agentId}'`));
+		console.log(result);
+		if (result.rows.length > 0) branches.push(branch);
+	} catch (error) {
+		console.debug(`Failed to query agent ${agentId} on branch ${branch.fullName}:`, error);
+	}
+	return branches;
+};
+
+//#endregion
+export { MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTenantMainBranch, isProtectedBranchName, listBranches, listBranchesForAgent };

package/dist/dolt/commit.d.ts

@@ -0,0 +1,94 @@
+import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
+
+//#region src/dolt/commit.d.ts
+
+/**
+ * Stage all changes for commit
+ * params: { tables?: string[] }
+ * tables: array of table names to stage
+ * if no tables are specified, all changes are staged
+ */
+declare const doltAdd: (db: AgentsManageDatabaseClient) => (params?: {
+  tables?: string[];
+}) => Promise<void>;
+/**
+ * Commit staged changes
+ * params: { message: string; author?: { name: string; email: string } }
+ * message: commit message
+ * author: commit author
+ * author is optional, if not provided, the commit will be committed with the default author
+ */
+declare const doltCommit: (db: AgentsManageDatabaseClient) => (params: {
+  message: string;
+  author?: {
+    name: string;
+    email: string;
+  };
+}) => Promise<string>;
+declare const doltAddAndCommit: (db: AgentsManageDatabaseClient) => (params: {
+  message: string;
+  author?: {
+    name: string;
+    email: string;
+  };
+}) => Promise<string>;
+/**
+ * Get commit log
+ */
+declare const doltLog: (db: AgentsManageDatabaseClient) => (params?: {
+  revision?: string;
+  limit?: number;
+}) => Promise<{
+  commit_hash: string;
+  committer: string;
+  email: string;
+  date: Date;
+  message: string;
+}[]>;
+/**
+ * Reset staged or working changes
+ */
+declare const doltReset: (db: AgentsManageDatabaseClient) => (params?: {
+  hard?: boolean;
+  tables?: string[];
+}) => Promise<void>;
+/**
+ * Get status of working changes
+ */
+declare const doltStatus: (db: AgentsManageDatabaseClient) => () => Promise<{
+  table_name: string;
+  staged: boolean;
+  status: string;
+}[]>;
+/**
+ * Get hash of a commit/branch
+ */
+declare const doltHashOf: (db: AgentsManageDatabaseClient) => (params: {
+  revision: string;
+}) => Promise<string>;
+/**
+ * Create a tag
+ */
+declare const doltTag: (db: AgentsManageDatabaseClient) => (params: {
+  name: string;
+  message?: string;
+  revision?: string;
+}) => Promise<void>;
+/**
+ * Delete a tag
+ */
+declare const doltDeleteTag: (db: AgentsManageDatabaseClient) => (params: {
+  name: string;
+}) => Promise<void>;
+/**
+ * List all tags
+ */
+declare const doltListTags: (db: AgentsManageDatabaseClient) => () => Promise<{
+  tag_name: string;
+  tag_hash: string;
+  tagger: string;
+  date: Date;
+  message: string;
+}[]>;
+//#endregion
+export { doltAdd, doltAddAndCommit, doltCommit, doltDeleteTag, doltHashOf, doltListTags, doltLog, doltReset, doltStatus, doltTag };

package/dist/dolt/commit.js

@@ -0,0 +1,103 @@
+import { doltListBranches } from "./branch.js";
+import { sql } from "drizzle-orm";
+
+//#region src/dolt/commit.ts
+/**
+* Stage all changes for commit
+* params: { tables?: string[] }
+* tables: array of table names to stage
+* if no tables are specified, all changes are staged
+*/
+const doltAdd = (db) => async (params = {}) => {
+	if (!params.tables || params.tables.length === 0) await db.execute(sql`SELECT DOLT_ADD('-A')`);
+	else {
+		const tableParams = params.tables.map((t) => `'${t}'`).join(", ");
+		console.log(tableParams);
+		await db.execute(sql.raw(`SELECT DOLT_ADD(${tableParams})`));
+	}
+};
+/**
+* Commit staged changes
+* params: { message: string; author?: { name: string; email: string } }
+* message: commit message
+* author: commit author
+* author is optional, if not provided, the commit will be committed with the default author
+*/
+const doltCommit = (db) => async (params) => {
+	const args = [];
+	args.push("'-a'");
+	args.push("'-m'", `'${params.message.replace(/'/g, "''")}'`);
+	if (params.author) args.push("'--author'", `'${params.author.name} <${params.author.email}>'`);
+	await db.execute(sql.raw(`SELECT DOLT_COMMIT(${args.join(", ")})`));
+	return "Commit successful";
+};
+const doltAddAndCommit = (db) => async (params) => {
+	await doltAdd(db)({});
+	return doltCommit(db)(params);
+};
+/**
+* Get commit log
+*/
+const doltLog = (db) => async (params) => {
+	let query = sql`SELECT * FROM DOLT_LOG()`;
+	if (params?.revision) query = sql.raw(`SELECT * FROM DOLT_LOG('${params.revision}')`);
+	let rows = (await db.execute(query)).rows;
+	if (params?.limit) rows = rows.slice(0, params.limit);
+	return rows;
+};
+/**
+* Reset staged or working changes
+*/
+const doltReset = (db) => async (params) => {
+	if (params?.hard) await db.execute(sql`SELECT DOLT_RESET('--hard')`);
+	else if (params?.tables && params.tables.length > 0) {
+		const tableParams = params.tables.map((t) => `'${t}'`).join(", ");
+		await db.execute(sql.raw(`SELECT DOLT_RESET(${tableParams})`));
+	} else await db.execute(sql`SELECT DOLT_RESET()`);
+};
+/**
+* Get status of working changes
+*/
+const doltStatus = (db) => async () => {
+	return (await db.execute(sql`SELECT * FROM dolt_status`)).rows;
+};
+/**
+* Get hash of a commit/branch
+*/
+const doltHashOf = (db) => async (params) => {
+	if (/^[0-9a-v]{32}$/.test(params.revision)) return params.revision;
+	if ((await doltListBranches(db)()).some((b) => b.name === params.revision)) {
+		const commitHash = (await db.execute(sql.raw(`SELECT commit_hash FROM DOLT_LOG('${params.revision}') LIMIT 1`))).rows[0]?.commit_hash;
+		if (!commitHash) throw new Error(`Could not find commit hash for branch '${params.revision}'`);
+		return commitHash;
+	}
+	const tag = (await doltListTags(db)()).find((t) => t.tag_name === params.revision);
+	if (tag) return tag.tag_hash;
+	const hash = (await db.execute(sql.raw(`SELECT DOLT_HASHOF('${params.revision}') as hash`))).rows[0]?.hash;
+	if (!hash) throw new Error(`Could not find commit hash for revision '${params.revision}'`);
+	return hash;
+};
+/**
+* Create a tag
+*/
+const doltTag = (db) => async (params) => {
+	const args = [`'${params.name}'`];
+	if (params.message) args.push("'-m'", `'${params.message.replace(/'/g, "''")}'`);
+	if (params.revision) args.push(`'${params.revision}'`);
+	await db.execute(sql.raw(`SELECT DOLT_TAG(${args.join(", ")})`));
+};
+/**
+* Delete a tag
+*/
+const doltDeleteTag = (db) => async (params) => {
+	await db.execute(sql.raw(`SELECT DOLT_TAG('-d', '${params.name}')`));
+};
+/**
+* List all tags
+*/
+const doltListTags = (db) => async () => {
+	return (await db.execute(sql`SELECT * FROM dolt_tags`)).rows;
+};
+
+//#endregion
+export { doltAdd, doltAddAndCommit, doltCommit, doltDeleteTag, doltHashOf, doltListTags, doltLog, doltReset, doltStatus, doltTag };

package/dist/dolt/diff.d.ts

@@ -0,0 +1,27 @@
+import { AgentsManageDatabaseClient } from "../db/manage/manage-client.js";
+
+//#region src/dolt/diff.d.ts
+
+/**
+ * Get diff between two commits/branches
+ */
+declare const doltDiff: (db: AgentsManageDatabaseClient) => (params: {
+  fromRevision: string;
+  toRevision: string;
+  tableName: string;
+}) => Promise<any[]>;
+/**
+ * Get diff summary between two commits/branches
+ */
+declare const doltDiffSummary: (db: AgentsManageDatabaseClient) => (params: {
+  fromRevision: string;
+  toRevision: string;
+  tableName?: string;
+}) => Promise<{
+  table_name: string;
+  diff_type: string;
+  data_change: boolean;
+  schema_change: boolean;
+}[]>;
+//#endregion
+export { doltDiff, doltDiffSummary };

package/dist/dolt/diff.js

@@ -0,0 +1,21 @@
+import { sql } from "drizzle-orm";
+
+//#region src/dolt/diff.ts
+/**
+* Get diff between two commits/branches
+*/
+const doltDiff = (db) => async (params) => {
+	return (await db.execute(sql.raw(`SELECT * FROM DOLT_DIFF('${params.fromRevision}', '${params.toRevision}', '${params.tableName}')`))).rows;
+};
+/**
+* Get diff summary between two commits/branches
+*/
+const doltDiffSummary = (db) => async (params) => {
+	let query;
+	if (params.tableName) query = sql.raw(`SELECT * FROM DOLT_DIFF_SUMMARY('${params.fromRevision}', '${params.toRevision}', '${params.tableName}')`);
+	else query = sql.raw(`SELECT * FROM DOLT_DIFF_SUMMARY('${params.fromRevision}', '${params.toRevision}')`);
+	return (await db.execute(query)).rows;
+};
+
+//#endregion
+export { doltDiff, doltDiffSummary };

package/dist/dolt/index.d.ts

@@ -0,0 +1,10 @@
+import { branchScopes, doltActiveBranch, doltBranch, doltBranchExists, doltCheckout, doltDeleteBranch, doltGetBranchNamespace, doltListBranches, doltRenameBranch, ensureBranchExists } from "./branch.js";
+import { CheckoutBranchParams, CheckoutBranchResult, CreateBranchParams, DeleteBranchParams, GetBranchParams, MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTenantMainBranch, isProtectedBranchName, listBranches, listBranchesForAgent } from "./branches-api.js";
+import { doltAdd, doltAddAndCommit, doltCommit, doltDeleteTag, doltHashOf, doltListTags, doltLog, doltReset, doltStatus, doltTag } from "./commit.js";
+import { doltDiff, doltDiffSummary } from "./diff.js";
+import { doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts } from "./merge.js";
+import { RefType, checkoutRef, getCurrentBranchOrCommit, getProjectMainResolvedRef, getProjectScopedRef, getTenantScopedRef, isRefWritable, isValidCommitHash, resolveRef } from "./ref-helpers.js";
+import { RefContext, RefMiddlewareOptions, createRefMiddleware, createWriteProtectionMiddleware, refMiddlewareFactory, writeProtectionMiddlewareFactory } from "./ref-middleware.js";
+import { NestedRefScopeError, WithRefOptions, getCurrentRefScope, getRefScopedDb, isInRefScope, withRef } from "./ref-scope.js";
+import { EnsureSchemaSyncOptions, SCHEMA_SOURCE_BRANCH, SchemaDiff, SchemaSyncOptions, SchemaSyncResult, areBranchesSchemaCompatible, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getSchemaDiff, hasSchemaDifferences, hasUncommittedChanges, syncSchemaFromMain } from "./schema-sync.js";
+export { CheckoutBranchParams, CheckoutBranchResult, CreateBranchParams, DeleteBranchParams, EnsureSchemaSyncOptions, GetBranchParams, MAIN_BRANCH_SUFFIX, NestedRefScopeError, RefContext, RefMiddlewareOptions, RefType, SCHEMA_SOURCE_BRANCH, SchemaDiff, SchemaSyncOptions, SchemaSyncResult, WithRefOptions, areBranchesSchemaCompatible, branchScopes, checkoutBranch, checkoutRef, createBranch, createRefMiddleware, createWriteProtectionMiddleware, deleteBranch, doltAbortMerge, doltActiveBranch, doltAdd, doltAddAndCommit, doltBranch, doltBranchExists, doltCheckout, doltCommit, doltConflicts, doltDeleteBranch, doltDeleteTag, doltDiff, doltDiffSummary, doltGetBranchNamespace, doltHashOf, doltListBranches, doltListTags, doltLog, doltMerge, doltMergeStatus, doltRenameBranch, doltReset, doltResolveConflicts, doltSchemaConflicts, doltStatus, doltTableConflicts, doltTag, ensureBranchExists, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getBranch, getCurrentBranchOrCommit, getCurrentRefScope, getProjectMainResolvedRef, getProjectScopedRef, getRefScopedDb, getSchemaDiff, getTenantMainBranch, getTenantScopedRef, hasSchemaDifferences, hasUncommittedChanges, isInRefScope, isProtectedBranchName, isRefWritable, isValidCommitHash, listBranches, listBranchesForAgent, refMiddlewareFactory, resolveRef, syncSchemaFromMain, withRef, writeProtectionMiddlewareFactory };

package/dist/dolt/index.js

@@ -0,0 +1,11 @@
+import { doltAdd, doltAddAndCommit, doltCommit, doltDeleteTag, doltHashOf, doltListTags, doltLog, doltReset, doltStatus, doltTag } from "./commit.js";
+import { doltAbortMerge, doltConflicts, doltMerge, doltMergeStatus, doltResolveConflicts, doltSchemaConflicts, doltTableConflicts } from "./merge.js";
+import { SCHEMA_SOURCE_BRANCH, areBranchesSchemaCompatible, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getSchemaDiff, hasSchemaDifferences, hasUncommittedChanges, syncSchemaFromMain } from "./schema-sync.js";
+import { MAIN_BRANCH_SUFFIX, checkoutBranch, createBranch, deleteBranch, getBranch, getTenantMainBranch, isProtectedBranchName, listBranches, listBranchesForAgent } from "./branches-api.js";
+import { checkoutRef, getCurrentBranchOrCommit, getProjectMainResolvedRef, getProjectScopedRef, getTenantScopedRef, isRefWritable, isValidCommitHash, resolveRef } from "./ref-helpers.js";
+import { doltActiveBranch, doltBranch, doltBranchExists, doltCheckout, doltDeleteBranch, doltGetBranchNamespace, doltListBranches, doltRenameBranch, ensureBranchExists } from "./branch.js";
+import { doltDiff, doltDiffSummary } from "./diff.js";
+import { createRefMiddleware, createWriteProtectionMiddleware, refMiddlewareFactory, writeProtectionMiddlewareFactory } from "./ref-middleware.js";
+import { NestedRefScopeError, getCurrentRefScope, getRefScopedDb, isInRefScope, withRef } from "./ref-scope.js";
+
+export { MAIN_BRANCH_SUFFIX, NestedRefScopeError, SCHEMA_SOURCE_BRANCH, areBranchesSchemaCompatible, checkoutBranch, checkoutRef, createBranch, createRefMiddleware, createWriteProtectionMiddleware, deleteBranch, doltAbortMerge, doltActiveBranch, doltAdd, doltAddAndCommit, doltBranch, doltBranchExists, doltCheckout, doltCommit, doltConflicts, doltDeleteBranch, doltDeleteTag, doltDiff, doltDiffSummary, doltGetBranchNamespace, doltHashOf, doltListBranches, doltListTags, doltLog, doltMerge, doltMergeStatus, doltRenameBranch, doltReset, doltResolveConflicts, doltSchemaConflicts, doltStatus, doltTableConflicts, doltTag, ensureBranchExists, ensureSchemaSync, formatSchemaDiffSummary, getActiveBranch, getBranch, getCurrentBranchOrCommit, getCurrentRefScope, getProjectMainResolvedRef, getProjectScopedRef, getRefScopedDb, getSchemaDiff, getTenantMainBranch, getTenantScopedRef, hasSchemaDifferences, hasUncommittedChanges, isInRefScope, isProtectedBranchName, isRefWritable, isValidCommitHash, listBranches, listBranchesForAgent, refMiddlewareFactory, resolveRef, syncSchemaFromMain, withRef, writeProtectionMiddlewareFactory };