@dbx-tools/appkit-mastra 0.6.8 → 0.6.9

package/lib/src/databricks-aitools.js

@@ -0,0 +1,150 @@
+/**
+ * Startup provisioning of Databricks AI Tools skills for a Mastra workspace.
+ *
+ * Databricks AI Tools (`databricks aitools`) are Databricks-owned Agent-Skill
+ * (`SKILL.md`) trees installed and kept up to date through the Databricks CLI.
+ * The CLI installs them globally under `~/.databricks/aitools/skills/<name>/`
+ * (with a `.state.json` manifest) and can also write a resolved, agent-agnostic
+ * copy to any directory with `databricks aitools install --path <dir>
+ * --skills-only`.
+ *
+ * {@link provisionDatabricksAITools} folds those skills into a Mastra workspace
+ * as extra LOCAL skill scan paths so an agent can use them without anyone
+ * hand-copying `SKILL.md` files. It never reimplements the CLI's sourcing: it
+ * either points Mastra at the already-installed global tree, or shells out to
+ * the CLI to materialize a curated subset into a temp dir.
+ *
+ * The option is `false | true | "auto" | DatabricksAIToolsOptions`:
+ *
+ * - `false` (default) - off.
+ * - `"auto"` - enable only when the global tree already exists OR the
+ *   `databricks` CLI is resolvable; otherwise silently no-op. The "on if the
+ *   CLI is around" default.
+ * - `true` - required: fail startup (subject to `failOnError`) when neither the
+ *   installed tree nor the CLI can supply skills.
+ * - an options bag for a specific `skills` subset, `experimental` skills, a
+ *   `refresh` that re-runs the CLI even when a tree exists, or an explicit
+ *   `path`.
+ *
+ * @module
+ */
+import { mkdtemp } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "@dbx-tools/core";
+import { error, log, string } from "@dbx-tools/shared-core";
+const logger = log.logger("mastra/databricks-aitools");
+/** Global skills tree the `databricks aitools` CLI installs into. */
+const GLOBAL_AITOOLS_SKILLS_PATH = join(homedir(), ".databricks", "aitools", "skills");
+/** The Databricks CLI binary name; resolved on `PATH`. */
+const DATABRICKS_CLI = "databricks";
+/* ------------------------------- helpers ------------------------------- */
+/** Normalize the `databricksAITools` option into a flat options bag, or `undefined` when off. */
+export function normalizeDatabricksAIToolsOption(option) {
+    if (option === undefined || option === false)
+        return undefined;
+    if (option === true)
+        return { mode: "require" };
+    if (option === "auto")
+        return { mode: "auto" };
+    return { mode: option.mode ?? "auto", ...option };
+}
+/**
+ * Materialize Databricks AI Tools skills at app startup and return them as
+ * extra local skill scan paths.
+ *
+ * Resolution: reuse the installed global tree when present (no CLI call) unless
+ * `refresh`/`skills`/`path` ask for a fresh CLI materialization; otherwise run
+ * `databricks aitools install --path <dir> --skills-only` when the CLI resolves.
+ * A `"require"` provision that yields nothing fails startup unless
+ * `failOnError: false`.
+ */
+export async function provisionDatabricksAITools(option) {
+    const options = normalizeDatabricksAIToolsOption(option);
+    const empty = { localSkillPaths: [] };
+    if (!options)
+        return empty;
+    const mode = options.mode ?? "auto";
+    const failOnError = options.failOnError ?? mode === "require";
+    const wantsCliFetch = options.refresh === true ||
+        options.path !== undefined ||
+        string.parseList(options.skills).length > 0 ||
+        options.experimental === true;
+    try {
+        // Fast path: reuse the already-installed global tree, no CLI call.
+        if (!wantsCliFetch && installedTreeExists()) {
+            logger.debug("using installed aitools tree", { path: GLOBAL_AITOOLS_SKILLS_PATH });
+            return { localSkillPaths: [GLOBAL_AITOOLS_SKILLS_PATH], source: "installed" };
+        }
+        const cliPath = await resolveCli(options.cli);
+        if (cliPath) {
+            const dir = await materializeViaCli(cliPath, options);
+            if (dir)
+                return { localSkillPaths: [dir], source: "cli" };
+        }
+        // Nothing fetched. Fall back to the installed tree if it's there.
+        if (installedTreeExists()) {
+            return { localSkillPaths: [GLOBAL_AITOOLS_SKILLS_PATH], source: "installed" };
+        }
+        if (failOnError) {
+            throw new Error(`Databricks AI Tools requested but no installed skills tree at "${GLOBAL_AITOOLS_SKILLS_PATH}" and the "${DATABRICKS_CLI}" CLI is not resolvable. Install with \`databricks aitools install\`, or set databricksAITools: "auto".`);
+        }
+        logger.debug("databricks aitools unavailable; skipping");
+        return empty;
+    }
+    catch (err) {
+        if (failOnError) {
+            throw new Error(`failed to provision Databricks AI Tools skills: ${error.errorMessage(err)}`, { cause: error.toError(err) });
+        }
+        logger.warn("skipped", { error: error.errorMessage(err) });
+        return empty;
+    }
+}
+/** Whether the CLI's global skills tree exists and holds at least one skill. */
+function installedTreeExists() {
+    return existsSync(GLOBAL_AITOOLS_SKILLS_PATH);
+}
+/** Resolve the `databricks` CLI, returning its invocation path or `undefined`. */
+async function resolveCli(cli) {
+    const command = string.trimToNull(cli) ?? DATABRICKS_CLI;
+    try {
+        const result = await spawn(command, ["aitools", "version"], {
+            stdout: "capture",
+            stderr: "capture",
+            check: false,
+        });
+        if (result.exitCode === 0)
+            return command;
+    }
+    catch {
+        // CLI absent or `aitools` unsupported - caller falls back / fails.
+    }
+    return undefined;
+}
+/**
+ * Run `databricks aitools install --path <dir> --skills-only` to materialize a
+ * resolved, agent-agnostic skill set into a directory (no agents, no state).
+ */
+async function materializeViaCli(cli, options) {
+    const dir = string.trimToNull(options.path) ?? (await mkdtemp(join(tmpdir(), "databricks-aitools-")));
+    const args = ["aitools", "install", "--path", dir, "--skills-only"];
+    const skills = string.parseList(options.skills);
+    if (skills.length > 0)
+        args.push("--skills", skills.join(","));
+    if (options.experimental)
+        args.push("--experimental");
+    const result = await spawn(cli, args, {
+        stdout: "capture",
+        stderr: "capture",
+        check: false,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(`databricks aitools install failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+    }
+    if (!existsSync(dir))
+        return undefined;
+    logger.debug("materialized aitools skills via CLI", { path: dir, skills });
+    return dir;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"databricks-aitools.js","sourceRoot":"","sources":["../../src/databricks-aitools.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Startup provisioning of Databricks AI Tools skills for a Mastra workspace.\n *\n * Databricks AI Tools (`databricks aitools`) are Databricks-owned Agent-Skill\n * (`SKILL.md`) trees installed and kept up to date through the Databricks CLI.\n * The CLI installs them globally under `~/.databricks/aitools/skills/<name>/`\n * (with a `.state.json` manifest) and can also write a resolved, agent-agnostic\n * copy to any directory with `databricks aitools install --path <dir>\n * --skills-only`.\n *\n * {@link provisionDatabricksAITools} folds those skills into a Mastra workspace\n * as extra LOCAL skill scan paths so an agent can use them without anyone\n * hand-copying `SKILL.md` files. It never reimplements the CLI's sourcing: it\n * either points Mastra at the already-installed global tree, or shells out to\n * the CLI to materialize a curated subset into a temp dir.\n *\n * The option is `false | true | \"auto\" | DatabricksAIToolsOptions`:\n *\n * - `false` (default) - off.\n * - `\"auto\"` - enable only when the global tree already exists OR the\n *   `databricks` CLI is resolvable; otherwise silently no-op. The \"on if the\n *   CLI is around\" default.\n * - `true` - required: fail startup (subject to `failOnError`) when neither the\n *   installed tree nor the CLI can supply skills.\n * - an options bag for a specific `skills` subset, `experimental` skills, a\n *   `refresh` that re-runs the CLI even when a tree exists, or an explicit\n *   `path`.\n *\n * @module\n */\n\nimport { mkdtemp } from \"node:fs/promises\";\nimport { existsSync } from \"node:fs\";\nimport { homedir, tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { spawn } from \"@dbx-tools/core\";\nimport { error, log, string } from \"@dbx-tools/shared-core\";\n\nconst logger = log.logger(\"mastra/databricks-aitools\");\n\n/** Global skills tree the `databricks aitools` CLI installs into. */\nconst GLOBAL_AITOOLS_SKILLS_PATH = join(homedir(), \".databricks\", \"aitools\", \"skills\");\n\n/** The Databricks CLI binary name; resolved on `PATH`. */\nconst DATABRICKS_CLI = \"databricks\";\n\n/* -------------------------------- types -------------------------------- */\n\n/** How aggressively to enable Databricks AI Tools skills. */\nexport type DatabricksAIToolsMode = \"auto\" | \"require\";\n\n/** Options for {@link provisionDatabricksAITools}. */\nexport interface DatabricksAIToolsOptions {\n  /**\n   * `\"auto\"` (default) enables only when the installed tree exists or the CLI\n   * is resolvable; `\"require\"` fails startup when neither can supply skills.\n   */\n  mode?: DatabricksAIToolsMode;\n  /** Install only these skill names (comma/space list or array). */\n  skills?: string | string[];\n  /** Include experimental skills when the CLI has to fetch. */\n  experimental?: boolean;\n  /**\n   * Re-run the CLI to (re)materialize skills into a fresh dir even when the\n   * global tree already exists. Defaults to `false` (reuse the installed tree).\n   */\n  refresh?: boolean;\n  /**\n   * Explicit directory to materialize skills into with the CLI. Defaults to a\n   * temp dir. Ignored when the installed global tree is used as-is.\n   */\n  path?: string;\n  /** Absolute path to the `databricks` CLI. Defaults to `databricks` on PATH. */\n  cli?: string;\n  /**\n   * Fail app startup when required skills can't be provisioned. Defaults to\n   * `true` for `mode: \"require\"` and `false` for `\"auto\"`.\n   */\n  failOnError?: boolean;\n}\n\n/** The `databricksAITools` config option: a toggle, `\"auto\"`, or an options bag. */\nexport type DatabricksAIToolsOption = boolean | \"auto\" | DatabricksAIToolsOptions;\n\n/** What {@link provisionDatabricksAITools} resolved. */\nexport interface ProvisionedDatabricksAITools {\n  /** Extra LOCAL skill scan paths to hand Mastra. Empty when disabled/unresolved. */\n  localSkillPaths: string[];\n  /** How the skills were sourced, for logging. */\n  source?: \"installed\" | \"cli\";\n}\n\n/* ------------------------------- helpers ------------------------------- */\n\n/** Normalize the `databricksAITools` option into a flat options bag, or `undefined` when off. */\nexport function normalizeDatabricksAIToolsOption(\n  option: DatabricksAIToolsOption | undefined,\n): DatabricksAIToolsOptions | undefined {\n  if (option === undefined || option === false) return undefined;\n  if (option === true) return { mode: \"require\" };\n  if (option === \"auto\") return { mode: \"auto\" };\n  return { mode: option.mode ?? \"auto\", ...option };\n}\n\n/**\n * Materialize Databricks AI Tools skills at app startup and return them as\n * extra local skill scan paths.\n *\n * Resolution: reuse the installed global tree when present (no CLI call) unless\n * `refresh`/`skills`/`path` ask for a fresh CLI materialization; otherwise run\n * `databricks aitools install --path <dir> --skills-only` when the CLI resolves.\n * A `\"require\"` provision that yields nothing fails startup unless\n * `failOnError: false`.\n */\nexport async function provisionDatabricksAITools(\n  option: DatabricksAIToolsOption | undefined,\n): Promise<ProvisionedDatabricksAITools> {\n  const options = normalizeDatabricksAIToolsOption(option);\n  const empty: ProvisionedDatabricksAITools = { localSkillPaths: [] };\n  if (!options) return empty;\n\n  const mode = options.mode ?? \"auto\";\n  const failOnError = options.failOnError ?? mode === \"require\";\n  const wantsCliFetch =\n    options.refresh === true ||\n    options.path !== undefined ||\n    string.parseList(options.skills).length > 0 ||\n    options.experimental === true;\n\n  try {\n    // Fast path: reuse the already-installed global tree, no CLI call.\n    if (!wantsCliFetch && installedTreeExists()) {\n      logger.debug(\"using installed aitools tree\", { path: GLOBAL_AITOOLS_SKILLS_PATH });\n      return { localSkillPaths: [GLOBAL_AITOOLS_SKILLS_PATH], source: \"installed\" };\n    }\n\n    const cliPath = await resolveCli(options.cli);\n    if (cliPath) {\n      const dir = await materializeViaCli(cliPath, options);\n      if (dir) return { localSkillPaths: [dir], source: \"cli\" };\n    }\n\n    // Nothing fetched. Fall back to the installed tree if it's there.\n    if (installedTreeExists()) {\n      return { localSkillPaths: [GLOBAL_AITOOLS_SKILLS_PATH], source: \"installed\" };\n    }\n\n    if (failOnError) {\n      throw new Error(\n        `Databricks AI Tools requested but no installed skills tree at \"${GLOBAL_AITOOLS_SKILLS_PATH}\" and the \"${DATABRICKS_CLI}\" CLI is not resolvable. Install with \\`databricks aitools install\\`, or set databricksAITools: \"auto\".`,\n      );\n    }\n    logger.debug(\"databricks aitools unavailable; skipping\");\n    return empty;\n  } catch (err) {\n    if (failOnError) {\n      throw new Error(\n        `failed to provision Databricks AI Tools skills: ${error.errorMessage(err)}`,\n        { cause: error.toError(err) },\n      );\n    }\n    logger.warn(\"skipped\", { error: error.errorMessage(err) });\n    return empty;\n  }\n}\n\n/** Whether the CLI's global skills tree exists and holds at least one skill. */\nfunction installedTreeExists(): boolean {\n  return existsSync(GLOBAL_AITOOLS_SKILLS_PATH);\n}\n\n/** Resolve the `databricks` CLI, returning its invocation path or `undefined`. */\nasync function resolveCli(cli: string | undefined): Promise<string | undefined> {\n  const command = string.trimToNull(cli) ?? DATABRICKS_CLI;\n  try {\n    const result = await spawn(command, [\"aitools\", \"version\"], {\n      stdout: \"capture\",\n      stderr: \"capture\",\n      check: false,\n    });\n    if (result.exitCode === 0) return command;\n  } catch {\n    // CLI absent or `aitools` unsupported - caller falls back / fails.\n  }\n  return undefined;\n}\n\n/**\n * Run `databricks aitools install --path <dir> --skills-only` to materialize a\n * resolved, agent-agnostic skill set into a directory (no agents, no state).\n */\nasync function materializeViaCli(\n  cli: string,\n  options: DatabricksAIToolsOptions,\n): Promise<string | undefined> {\n  const dir =\n    string.trimToNull(options.path) ?? (await mkdtemp(join(tmpdir(), \"databricks-aitools-\")));\n  const args = [\"aitools\", \"install\", \"--path\", dir, \"--skills-only\"];\n  const skills = string.parseList(options.skills);\n  if (skills.length > 0) args.push(\"--skills\", skills.join(\",\"));\n  if (options.experimental) args.push(\"--experimental\");\n\n  const result = await spawn(cli, args, {\n    stdout: \"capture\",\n    stderr: \"capture\",\n    check: false,\n  });\n  if (result.exitCode !== 0) {\n    throw new Error(\n      `databricks aitools install failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`,\n    );\n  }\n  if (!existsSync(dir)) return undefined;\n  logger.debug(\"materialized aitools skills via CLI\", { path: dir, skills });\n  return dir;\n}\n"]}