@inkeep/agents-core 0.63.3 → 0.64.2

package/dist/db/runtime/runtime-schema.js

@@ -1,8 +1,8 @@
 import { __exportAll } from "../../_virtual/rolldown_runtime.js";
 import { account, deviceCode, invitation, member, organization, session, ssoProvider, user, verification } from "../../auth/auth-schema.js";
 import { USAGE_GENERATION_TYPES } from "../../constants/otel-attributes.js";
-import { relations } from "drizzle-orm";
-import { boolean, foreignKey, index, integer, jsonb, pgTable, primaryKey, text, timestamp, unique, uniqueIndex, varchar } from "drizzle-orm/pg-core";
+import { relations, sql } from "drizzle-orm";
+import { boolean, check, foreignKey, index, integer, jsonb, pgTable, primaryKey, text, timestamp, unique, uniqueIndex, varchar } from "drizzle-orm/pg-core";
 
 //#region src/db/runtime/runtime-schema.ts
 var runtime_schema_exports = /* @__PURE__ */ __exportAll({
@@ -24,6 +24,7 @@ var runtime_schema_exports = /* @__PURE__ */ __exportAll({
 	member: () => member,
 	messages: () => messages,
 	messagesRelations: () => messagesRelations,
+	orgEntitlement: () => orgEntitlement,
 	organization: () => organization,
 	projectMetadata: () => projectMetadata,
 	scheduledTriggerInvocations: () => scheduledTriggerInvocations,
@@ -870,6 +871,22 @@ const workAppSlackMcpToolAccessConfig = pgTable("work_app_slack_mcp_tool_access_
 		name: "work_app_slack_mcp_tool_access_config_tenant_fk"
 	}).onDelete("cascade")
 ]);
+const orgEntitlement = pgTable("org_entitlement", {
+	id: varchar("id", { length: 256 }).primaryKey(),
+	organizationId: varchar("organization_id", { length: 256 }).notNull(),
+	resourceType: text("resource_type").notNull(),
+	maxValue: integer("max_value").notNull(),
+	...timestamps
+}, (table) => [
+	unique("org_entitlement_org_resource_unique").on(table.organizationId, table.resourceType),
+	index("org_entitlement_org_idx").on(table.organizationId),
+	foreignKey({
+		columns: [table.organizationId],
+		foreignColumns: [organization.id],
+		name: "org_entitlement_organization_fk"
+	}).onDelete("cascade"),
+	check("org_entitlement_resource_type_format", sql`resource_type ~ '^[a-z]+:[a-z][a-z0-9_]*$'`)
+]);
 
 //#endregion
-export { USAGE_GENERATION_TYPES, account, apiKeys, apps, contextCache, conversations, conversationsRelations, datasetRun, datasetRunConversationRelations, deviceCode, evaluationResult, evaluationRun, invitation, ledgerArtifacts, ledgerArtifactsRelations, member, messages, messagesRelations, organization, projectMetadata, runtime_schema_exports, scheduledTriggerInvocations, scheduledTriggers, schedulerState, session, ssoProvider, taskRelations, taskRelationsRelations, tasks, tasksRelations, triggerInvocations, user, userProfile, userProfileRelations, verification, workAppGitHubInstallations, workAppGitHubInstallationsRelations, workAppGitHubMcpToolAccessMode, workAppGitHubMcpToolRepositoryAccess, workAppGitHubMcpToolRepositoryAccessRelations, workAppGitHubProjectAccessMode, workAppGitHubProjectRepositoryAccess, workAppGitHubProjectRepositoryAccessRelations, workAppGitHubRepositories, workAppGitHubRepositoriesRelations, workAppSlackChannelAgentConfigs, workAppSlackMcpToolAccessConfig, workAppSlackUserMappings, workAppSlackWorkspaces, workflowExecutions };
+export { USAGE_GENERATION_TYPES, account, apiKeys, apps, contextCache, conversations, conversationsRelations, datasetRun, datasetRunConversationRelations, deviceCode, evaluationResult, evaluationRun, invitation, ledgerArtifacts, ledgerArtifactsRelations, member, messages, messagesRelations, orgEntitlement, organization, projectMetadata, runtime_schema_exports, scheduledTriggerInvocations, scheduledTriggers, schedulerState, session, ssoProvider, taskRelations, taskRelationsRelations, tasks, tasksRelations, triggerInvocations, user, userProfile, userProfileRelations, verification, workAppGitHubInstallations, workAppGitHubInstallationsRelations, workAppGitHubMcpToolAccessMode, workAppGitHubMcpToolRepositoryAccess, workAppGitHubMcpToolRepositoryAccessRelations, workAppGitHubProjectAccessMode, workAppGitHubProjectRepositoryAccess, workAppGitHubProjectRepositoryAccessRelations, workAppGitHubRepositories, workAppGitHubRepositoriesRelations, workAppSlackChannelAgentConfigs, workAppSlackMcpToolAccessConfig, workAppSlackUserMappings, workAppSlackWorkspaces, workflowExecutions };

package/dist/dolt/backfill-skill-files.d.ts

@@ -0,0 +1,41 @@
+//#region src/dolt/backfill-skill-files.d.ts
+type SkillBackfillSource = {
+  tenantId: string;
+  projectId: string;
+  id: string;
+  name: string;
+  description: string;
+  content: string;
+  metadata: Record<string, string> | null;
+  createdAt: string;
+  updatedAt: string;
+};
+type ExistingSkillEntryFile = {
+  tenantId: string;
+  projectId: string;
+  skillId: string;
+};
+type BackfillSkillFilesArgs = {
+  apply: boolean;
+  branchNames: string[];
+  continueOnError: boolean;
+  help: boolean;
+  includeMain: boolean;
+};
+declare function buildLegacySkillFileId(skill: Pick<SkillBackfillSource, 'tenantId' | 'projectId' | 'id'>): string;
+declare function buildMissingSkillFileRows(sourceSkills: SkillBackfillSource[], existingSkillEntryFiles: ExistingSkillEntryFile[]): {
+  tenantId: string;
+  id: string;
+  projectId: string;
+  skillId: string;
+  filePath: string;
+  content: string;
+  createdAt: string;
+  updatedAt: string;
+}[];
+declare function parseBackfillSkillFilesArgs(argv: string[]): BackfillSkillFilesArgs;
+declare function getBackfillSkillFilesUsage(): string;
+declare function backfillSkillFilesAcrossAllBranches(options: Omit<BackfillSkillFilesArgs, 'help'>): Promise<void>;
+declare function main(argv?: string[]): Promise<void>;
+//#endregion
+export { BackfillSkillFilesArgs, backfillSkillFilesAcrossAllBranches, buildLegacySkillFileId, buildMissingSkillFileRows, getBackfillSkillFilesUsage, main, parseBackfillSkillFilesArgs };

package/dist/dolt/backfill-skill-files.js

@@ -0,0 +1,209 @@
+import { manage_schema_exports, skillFiles, skills } from "../db/manage/manage-schema.js";
+import { loadEnvironmentFiles } from "../env.js";
+import { createAgentsManageDatabasePool } from "../db/manage/manage-client.js";
+import { doltReset } from "./commit.js";
+import { doltListBranches } from "./branch.js";
+import { confirmMigration } from "../db/utils.js";
+import { eq } from "drizzle-orm";
+import { stringify } from "yaml";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { createHash } from "node:crypto";
+
+//#region src/dolt/backfill-skill-files.ts
+const DEFAULT_AUTHOR = {
+	name: "migration-script",
+	email: "migration@inkeep.com"
+};
+const DEFAULT_COMMIT_MESSAGE = "Backfill legacy SKILL.md skill files";
+const SKILL_ENTRY_FILE_PATH = "SKILL.md";
+function serializeSkillEntryFile(skill) {
+	return [
+		"---",
+		stringify({
+			name: skill.name,
+			description: skill.description,
+			metadata: skill.metadata ?? void 0
+		}).trimEnd(),
+		"---",
+		"",
+		skill.content
+	].join("\n");
+}
+function buildLegacySkillFileId(skill) {
+	return `legacy-${createHash("md5").update(`${skill.tenantId}:${skill.projectId}:${skill.id}:${SKILL_ENTRY_FILE_PATH}`).digest("hex")}`;
+}
+function buildMissingSkillFileRows(sourceSkills, existingSkillEntryFiles) {
+	const existingKeys = new Set(existingSkillEntryFiles.map((file) => `${file.tenantId}:${file.projectId}:${file.skillId}:${SKILL_ENTRY_FILE_PATH}`));
+	return sourceSkills.filter((skill) => !existingKeys.has(`${skill.tenantId}:${skill.projectId}:${skill.id}:${SKILL_ENTRY_FILE_PATH}`)).map((skill) => ({
+		tenantId: skill.tenantId,
+		id: buildLegacySkillFileId(skill),
+		projectId: skill.projectId,
+		skillId: skill.id,
+		filePath: SKILL_ENTRY_FILE_PATH,
+		content: serializeSkillEntryFile(skill),
+		createdAt: skill.createdAt,
+		updatedAt: skill.updatedAt
+	}));
+}
+function readNextArg(argv, index, flag) {
+	const value = argv[index + 1];
+	if (!value || value.startsWith("--")) throw new Error(`Missing value for ${flag}`);
+	return value;
+}
+function parseBackfillSkillFilesArgs(argv) {
+	const parsed = {
+		apply: false,
+		branchNames: [],
+		continueOnError: false,
+		help: false,
+		includeMain: true
+	};
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		switch (arg) {
+			case "--apply":
+				parsed.apply = true;
+				break;
+			case "--branch":
+				parsed.branchNames.push(readNextArg(argv, index, arg));
+				index += 1;
+				break;
+			case "--continue-on-error":
+				parsed.continueOnError = true;
+				break;
+			case "--help":
+			case "-h":
+				parsed.help = true;
+				break;
+			case "--skip-main":
+				parsed.includeMain = false;
+				break;
+			default: throw new Error(`Unknown argument: ${arg}`);
+		}
+	}
+	return parsed;
+}
+function getBackfillSkillFilesUsage() {
+	return [
+		"Backfill legacy SKILL.md files from skills rows across Dolt branches.",
+		"",
+		"Usage:",
+		"  tsx packages/agents-core/scripts/backfill-skill-files.ts [options]",
+		"",
+		"Options:",
+		"  --apply                 Persist and commit changes. Default is dry-run.",
+		"  --branch <name>         Limit execution to a branch. Repeatable.",
+		"  --skip-main             Exclude main.",
+		"  --continue-on-error     Continue processing remaining branches after failures.",
+		"  --help, -h              Show this help text."
+	].join("\n");
+}
+async function tableExists(connection, tableName) {
+	return (await connection.query(`SELECT 1
+     FROM information_schema.tables
+     WHERE table_schema = 'public'
+       AND table_name = $1
+     LIMIT 1`, [tableName])).rows.length > 0;
+}
+async function backfillSkillFilesAcrossAllBranches(options) {
+	loadEnvironmentFiles();
+	const connectionString = process.env.INKEEP_AGENTS_MANAGE_DATABASE_URL;
+	await confirmMigration(connectionString);
+	const pool = createAgentsManageDatabasePool({
+		connectionString,
+		poolSize: 2
+	});
+	try {
+		const targetBranches = (await doltListBranches(drizzle(pool, { schema: manage_schema_exports }))()).filter((branch) => {
+			if (!options.includeMain && branch.name === "main") return false;
+			if (options.branchNames.length > 0 && !options.branchNames.includes(branch.name)) return false;
+			return true;
+		});
+		if (targetBranches.length === 0) {
+			console.log("No matching branches found.");
+			return;
+		}
+		console.log(`${options.apply ? "Applying" : "Dry-running"} SKILL.md backfill on ${targetBranches.length} branch(es)\n`);
+		let changedBranches = 0;
+		let noopBranches = 0;
+		let skippedBranches = 0;
+		let failedBranches = 0;
+		let insertedRows = 0;
+		for (const branch of targetBranches) {
+			const connection = await pool.connect();
+			const branchDb = drizzle(connection, { schema: manage_schema_exports });
+			try {
+				await connection.query("SELECT DOLT_CHECKOUT($1)", [branch.name]);
+				const hasSkillsTable = await tableExists(connection, "skills");
+				const hasSkillFilesTable = await tableExists(connection, "skill_files");
+				if (!hasSkillsTable || !hasSkillFilesTable) {
+					skippedBranches += 1;
+					console.log(`Branch "${branch.name}": skipped (missing skills or skill_files table)`);
+					continue;
+				}
+				const missingRows = buildMissingSkillFileRows(await branchDb.select({
+					tenantId: skills.tenantId,
+					projectId: skills.projectId,
+					id: skills.id,
+					name: skills.name,
+					description: skills.description,
+					content: skills.content,
+					metadata: skills.metadata,
+					createdAt: skills.createdAt,
+					updatedAt: skills.updatedAt
+				}).from(skills), await branchDb.select({
+					tenantId: skillFiles.tenantId,
+					projectId: skillFiles.projectId,
+					skillId: skillFiles.skillId
+				}).from(skillFiles).where(eq(skillFiles.filePath, SKILL_ENTRY_FILE_PATH)));
+				if (missingRows.length === 0) {
+					noopBranches += 1;
+					console.log(`Branch "${branch.name}": no changes`);
+					continue;
+				}
+				if (options.apply) {
+					await branchDb.insert(skillFiles).values(missingRows).onConflictDoNothing();
+					await connection.query("SELECT DOLT_COMMIT('-a', '-m', $1, '--author', $2)", [DEFAULT_COMMIT_MESSAGE, `${DEFAULT_AUTHOR.name} <${DEFAULT_AUTHOR.email}>`]);
+					console.log(`Branch "${branch.name}": inserted ${missingRows.length} SKILL.md file(s)`);
+				} else console.log(`Branch "${branch.name}": would insert ${missingRows.length} SKILL.md file(s)`);
+				changedBranches += 1;
+				insertedRows += missingRows.length;
+			} catch (error) {
+				failedBranches += 1;
+				try {
+					await doltReset(branchDb)({ hard: true });
+				} catch {}
+				const message = error instanceof Error ? error.message : String(error);
+				console.error(`Branch "${branch.name}": failed`);
+				console.error(`  ${message}`);
+				if (!options.continueOnError) throw error;
+			} finally {
+				try {
+					await connection.query("SELECT DOLT_CHECKOUT('main')");
+				} catch {}
+				connection.release();
+			}
+		}
+		console.log("");
+		console.log(`Summary: ${changedBranches} changed, ${noopBranches} no-op, ${skippedBranches} skipped, ${failedBranches} failed, ${insertedRows} SKILL.md file(s) ${options.apply ? "inserted" : "would be inserted"}`);
+		if (failedBranches > 0) process.exitCode = 1;
+	} finally {
+		await pool.end();
+	}
+}
+async function main(argv = process.argv.slice(2)) {
+	const parsedArgs = parseBackfillSkillFilesArgs(argv);
+	if (parsedArgs.help) {
+		console.log(getBackfillSkillFilesUsage());
+		return;
+	}
+	await backfillSkillFilesAcrossAllBranches({
+		apply: parsedArgs.apply,
+		branchNames: parsedArgs.branchNames,
+		continueOnError: parsedArgs.continueOnError,
+		includeMain: parsedArgs.includeMain
+	});
+}
+
+//#endregion
+export { backfillSkillFilesAcrossAllBranches, buildLegacySkillFileId, buildMissingSkillFileRows, getBackfillSkillFilesUsage, main, parseBackfillSkillFilesArgs };

package/dist/dolt/run-sql-file-on-all-branches.d.ts

@@ -0,0 +1,29 @@
+//#region src/dolt/run-sql-file-on-all-branches.d.ts
+type RunSqlFileOnAllBranchesArgs = {
+  apply: boolean;
+  branchNames: string[];
+  continueOnError: boolean;
+  filePath?: string;
+  help: boolean;
+  includeMain: boolean;
+};
+declare function buildDefaultCommitMessage(sqlFilePath: string): string;
+declare function resolveSqlFilePath(inputPath: string, cwd?: string): string;
+declare function parseRunSqlFileOnAllBranchesArgs(argv: string[]): RunSqlFileOnAllBranchesArgs;
+declare function getRunSqlFileOnAllBranchesUsage(): string;
+type RunSqlFileOnAllBranchesOptions = {
+  apply: boolean;
+  author: {
+    email: string;
+    name: string;
+  };
+  branchNames: string[];
+  commitMessage: string;
+  continueOnError: boolean;
+  includeMain: boolean;
+  sqlFilePath: string;
+};
+declare function runSqlFileOnAllBranches(options: RunSqlFileOnAllBranchesOptions): Promise<void>;
+declare function main(argv?: string[]): Promise<void>;
+//#endregion
+export { RunSqlFileOnAllBranchesArgs, buildDefaultCommitMessage, getRunSqlFileOnAllBranchesUsage, main, parseRunSqlFileOnAllBranchesArgs, resolveSqlFilePath, runSqlFileOnAllBranches };

package/dist/dolt/run-sql-file-on-all-branches.js

@@ -0,0 +1,177 @@
+import { manage_schema_exports } from "../db/manage/manage-schema.js";
+import { loadEnvironmentFiles } from "../env.js";
+import { createAgentsManageDatabasePool } from "../db/manage/manage-client.js";
+import { doltReset, doltStatus } from "./commit.js";
+import { doltListBranches } from "./branch.js";
+import { confirmMigration } from "../db/utils.js";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { fileURLToPath } from "node:url";
+
+//#region src/dolt/run-sql-file-on-all-branches.ts
+const DEFAULT_AUTHOR = {
+	name: "migration-script",
+	email: "migration@inkeep.com"
+};
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const repoRoot = path.resolve(packageRoot, "..", "..");
+function buildDefaultCommitMessage(sqlFilePath) {
+	return `Apply backfill SQL from ${path.basename(sqlFilePath)}`;
+}
+function resolveSqlFilePath(inputPath, cwd = process.cwd()) {
+	const candidates = path.isAbsolute(inputPath) ? [inputPath] : [
+		path.resolve(cwd, inputPath),
+		path.resolve(packageRoot, inputPath),
+		path.resolve(repoRoot, inputPath)
+	];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+	throw new Error(`SQL file not found: ${inputPath}`);
+}
+function readNextArg(argv, index, flag) {
+	const value = argv[index + 1];
+	if (!value || value.startsWith("--")) throw new Error(`Missing value for ${flag}`);
+	return value;
+}
+function parseRunSqlFileOnAllBranchesArgs(argv) {
+	const parsed = {
+		apply: false,
+		branchNames: [],
+		continueOnError: false,
+		help: false,
+		includeMain: true
+	};
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		switch (arg) {
+			case "--apply":
+				parsed.apply = true;
+				break;
+			case "--branch":
+				parsed.branchNames.push(readNextArg(argv, index, arg));
+				index += 1;
+				break;
+			case "--continue-on-error":
+				parsed.continueOnError = true;
+				break;
+			case "--file":
+			case "-f":
+				parsed.filePath = readNextArg(argv, index, arg);
+				index += 1;
+				break;
+			case "--help":
+			case "-h":
+				parsed.help = true;
+				break;
+			case "--skip-main":
+				parsed.includeMain = false;
+				break;
+			default: throw new Error(`Unknown argument: ${arg}`);
+		}
+	}
+	if (!parsed.help && !parsed.filePath) throw new Error("Missing required argument: --file <path-to-sql>");
+	return parsed;
+}
+function getRunSqlFileOnAllBranchesUsage() {
+	return [
+		"Run a SQL backfill file across Dolt branches.",
+		"",
+		"Usage:",
+		"  tsx packages/agents-core/scripts/run-manage-backfill-on-all-branches.ts --file <path> [options]",
+		"",
+		"Options:",
+		"  --apply                 Persist and commit changes. Default is dry-run.",
+		"  --file, -f <path>       SQL file to execute.",
+		"  --branch <name>         Limit execution to a branch. Repeatable.",
+		"  --skip-main             Exclude main.",
+		"  --continue-on-error     Continue processing remaining branches after failures.",
+		"  --help, -h              Show this help text."
+	].join("\n");
+}
+async function runSqlFileOnAllBranches(options) {
+	loadEnvironmentFiles();
+	const connectionString = process.env.INKEEP_AGENTS_MANAGE_DATABASE_URL;
+	await confirmMigration(connectionString);
+	const resolvedSqlFilePath = resolveSqlFilePath(options.sqlFilePath);
+	const sqlFileContents = readFileSync(resolvedSqlFilePath, "utf8").trim();
+	if (!sqlFileContents) throw new Error(`SQL file is empty: ${resolvedSqlFilePath}`);
+	const pool = createAgentsManageDatabasePool({
+		connectionString,
+		poolSize: 2
+	});
+	try {
+		const targetBranches = (await doltListBranches(drizzle(pool, { schema: manage_schema_exports }))()).filter((branch) => {
+			if (!options.includeMain && branch.name === "main") return false;
+			if (options.branchNames.length > 0 && !options.branchNames.includes(branch.name)) return false;
+			return true;
+		});
+		if (targetBranches.length === 0) {
+			console.log("No matching branches found.");
+			return;
+		}
+		console.log(`${options.apply ? "Applying" : "Dry-running"} ${path.basename(resolvedSqlFilePath)} on ${targetBranches.length} branch(es)\n`);
+		let changedBranches = 0;
+		let noopBranches = 0;
+		let failedBranches = 0;
+		for (const branch of targetBranches) {
+			const connection = await pool.connect();
+			const branchDb = drizzle(connection, { schema: manage_schema_exports });
+			try {
+				await connection.query("SELECT DOLT_CHECKOUT($1)", [branch.name]);
+				await connection.query(sqlFileContents);
+				const status = await doltStatus(branchDb)();
+				if (status.length === 0) {
+					noopBranches += 1;
+					console.log(`Branch "${branch.name}": no changes`);
+					continue;
+				}
+				if (options.apply) {
+					await connection.query("SELECT DOLT_COMMIT('-a', '-m', $1, '--author', $2)", [options.commitMessage, `${options.author.name} <${options.author.email}>`]);
+					console.log(`Branch "${branch.name}": applied and committed`);
+				} else {
+					await doltReset(branchDb)({ hard: true });
+					console.log(`Branch "${branch.name}": would change (${status.length} tracked change(s))`);
+				}
+				changedBranches += 1;
+			} catch (error) {
+				failedBranches += 1;
+				try {
+					await doltReset(branchDb)({ hard: true });
+				} catch {}
+				const message = error instanceof Error ? error.message : String(error);
+				console.error(`Branch "${branch.name}": failed`);
+				console.error(`  ${message}`);
+				if (!options.continueOnError) throw error;
+			} finally {
+				try {
+					await connection.query("SELECT DOLT_CHECKOUT('main')");
+				} catch {}
+				connection.release();
+			}
+		}
+		console.log("");
+		console.log(`Summary: ${changedBranches} changed, ${noopBranches} no-op, ${failedBranches} failed`);
+		if (failedBranches > 0) process.exitCode = 1;
+	} finally {
+		await pool.end();
+	}
+}
+async function main(argv = process.argv.slice(2)) {
+	const parsedArgs = parseRunSqlFileOnAllBranchesArgs(argv);
+	if (parsedArgs.help) {
+		console.log(getRunSqlFileOnAllBranchesUsage());
+		return;
+	}
+	await runSqlFileOnAllBranches({
+		apply: parsedArgs.apply,
+		author: DEFAULT_AUTHOR,
+		branchNames: parsedArgs.branchNames,
+		commitMessage: buildDefaultCommitMessage(parsedArgs.filePath ?? "backfill.sql"),
+		continueOnError: parsedArgs.continueOnError,
+		includeMain: parsedArgs.includeMain,
+		sqlFilePath: parsedArgs.filePath ?? ""
+	});
+}
+
+//#endregion
+export { buildDefaultCommitMessage, getRunSqlFileOnAllBranchesUsage, main, parseRunSqlFileOnAllBranchesArgs, resolveSqlFilePath, runSqlFileOnAllBranches };