@dexto/agent-management 1.2.5

package/dist/utils/api-key-resolver.cjs

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_key_resolver_exports = {};
+__export(api_key_resolver_exports, {
+  PROVIDER_API_KEY_MAP: () => PROVIDER_API_KEY_MAP,
+  getPrimaryApiKeyEnvVar: () => getPrimaryApiKeyEnvVar,
+  resolveApiKeyForProvider: () => resolveApiKeyForProvider
+});
+module.exports = __toCommonJS(api_key_resolver_exports);
+const PROVIDER_API_KEY_MAP = {
+  openai: ["OPENAI_API_KEY", "OPENAI_KEY"],
+  "openai-compatible": ["OPENAI_API_KEY", "OPENAI_KEY"],
+  // Uses same keys as openai
+  anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_KEY", "CLAUDE_API_KEY"],
+  google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY", "GEMINI_API_KEY"],
+  groq: ["GROQ_API_KEY"],
+  cohere: ["COHERE_API_KEY"],
+  xai: ["XAI_API_KEY", "X_AI_API_KEY"]
+  // perplexity: ['PERPLEXITY_API_KEY'],
+  // together: ['TOGETHER_API_KEY'],
+  // fireworks: ['FIREWORKS_API_KEY'],
+  // deepseek: ['DEEPSEEK_API_KEY'],
+};
+function resolveApiKeyForProvider(provider) {
+  const envVars = PROVIDER_API_KEY_MAP[provider];
+  if (!envVars) {
+    return void 0;
+  }
+  for (const envVar of envVars) {
+    const value = process.env[envVar];
+    if (value && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function getPrimaryApiKeyEnvVar(provider) {
+  const envVars = PROVIDER_API_KEY_MAP[provider];
+  return envVars?.[0] || `${provider.toUpperCase()}_API_KEY`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROVIDER_API_KEY_MAP,
+  getPrimaryApiKeyEnvVar,
+  resolveApiKeyForProvider
+});

package/dist/utils/api-key-resolver.d.ts

@@ -0,0 +1,21 @@
+import type { LLMProvider } from '@dexto/core';
+/**
+ * Utility for resolving API keys from environment variables.
+ * This consolidates the API key resolution logic used across CLI and core components.
+ */
+export declare const PROVIDER_API_KEY_MAP: Record<LLMProvider, string[]>;
+/**
+ * Resolves API key for a given provider from environment variables.
+ *
+ * @param provider The LLM provider
+ * @returns Resolved API key or undefined if not found
+ */
+export declare function resolveApiKeyForProvider(provider: LLMProvider): string | undefined;
+/**
+ * Gets the primary environment variable name for a provider (for display/error messages).
+ *
+ * @param provider The LLM provider
+ * @returns Primary environment variable name
+ */
+export declare function getPrimaryApiKeyEnvVar(provider: LLMProvider): string;
+//# sourceMappingURL=api-key-resolver.d.ts.map

package/dist/utils/api-key-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-key-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/api-key-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;GAGG;AAGH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,CAY9D,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAelF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAGpE"}

package/dist/utils/api-key-resolver.js

@@ -0,0 +1,36 @@
+const PROVIDER_API_KEY_MAP = {
+  openai: ["OPENAI_API_KEY", "OPENAI_KEY"],
+  "openai-compatible": ["OPENAI_API_KEY", "OPENAI_KEY"],
+  // Uses same keys as openai
+  anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_KEY", "CLAUDE_API_KEY"],
+  google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY", "GEMINI_API_KEY"],
+  groq: ["GROQ_API_KEY"],
+  cohere: ["COHERE_API_KEY"],
+  xai: ["XAI_API_KEY", "X_AI_API_KEY"]
+  // perplexity: ['PERPLEXITY_API_KEY'],
+  // together: ['TOGETHER_API_KEY'],
+  // fireworks: ['FIREWORKS_API_KEY'],
+  // deepseek: ['DEEPSEEK_API_KEY'],
+};
+function resolveApiKeyForProvider(provider) {
+  const envVars = PROVIDER_API_KEY_MAP[provider];
+  if (!envVars) {
+    return void 0;
+  }
+  for (const envVar of envVars) {
+    const value = process.env[envVar];
+    if (value && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function getPrimaryApiKeyEnvVar(provider) {
+  const envVars = PROVIDER_API_KEY_MAP[provider];
+  return envVars?.[0] || `${provider.toUpperCase()}_API_KEY`;
+}
+export {
+  PROVIDER_API_KEY_MAP,
+  getPrimaryApiKeyEnvVar,
+  resolveApiKeyForProvider
+};

package/dist/utils/api-key-store.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_key_store_exports = {};
+__export(api_key_store_exports, {
+  getProviderKeyStatus: () => getProviderKeyStatus,
+  listProviderKeyStatus: () => listProviderKeyStatus,
+  saveProviderApiKey: () => saveProviderApiKey
+});
+module.exports = __toCommonJS(api_key_store_exports);
+var import_api_key_resolver = require("./api-key-resolver.js");
+var import_core = require("@dexto/core");
+var import_path = require("./path.js");
+var import_env_file = require("./env-file.js");
+async function saveProviderApiKey(provider, apiKey, startPath) {
+  if (!provider) throw new Error("provider is required");
+  if (!apiKey || !apiKey.trim()) throw new Error("apiKey is required");
+  const envVar = (0, import_api_key_resolver.getPrimaryApiKeyEnvVar)(provider);
+  const targetEnvPath = (0, import_path.getDextoEnvPath)(startPath);
+  await (0, import_env_file.updateEnvFile)(targetEnvPath, { [envVar]: apiKey });
+  process.env[envVar] = apiKey;
+  return { envVar, targetEnvPath };
+}
+function getProviderKeyStatus(provider) {
+  const envVar = (0, import_api_key_resolver.getPrimaryApiKeyEnvVar)(provider);
+  const key = (0, import_api_key_resolver.resolveApiKeyForProvider)(provider);
+  return { hasApiKey: Boolean(key && key.trim()), envVar };
+}
+function listProviderKeyStatus() {
+  const result = {};
+  for (const provider of import_core.LLM_PROVIDERS) {
+    result[provider] = getProviderKeyStatus(provider);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getProviderKeyStatus,
+  listProviderKeyStatus,
+  saveProviderApiKey
+});

package/dist/utils/api-key-store.d.ts

@@ -0,0 +1,18 @@
+import type { LLMProvider } from '@dexto/core';
+/**
+ * Save provider API key to the correct .env and make it immediately available in-process.
+ * Never returns the key; only metadata for callers to display.
+ */
+export declare function saveProviderApiKey(provider: LLMProvider, apiKey: string, startPath?: string): Promise<{
+    envVar: string;
+    targetEnvPath: string;
+}>;
+export declare function getProviderKeyStatus(provider: LLMProvider): {
+    hasApiKey: boolean;
+    envVar: string;
+};
+export declare function listProviderKeyStatus(): Record<string, {
+    hasApiKey: boolean;
+    envVar: string;
+}>;
+//# sourceMappingURL=api-key-store.d.ts.map

package/dist/utils/api-key-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-key-store.d.ts","sourceRoot":"","sources":["../../src/utils/api-key-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM/C;;;GAGG;AACH,wBAAsB,kBAAkB,CACpC,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAYpD;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,WAAW,GAAG;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAClB,CAIA;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAM9F"}

package/dist/utils/api-key-store.js

@@ -0,0 +1,30 @@
+import { getPrimaryApiKeyEnvVar, resolveApiKeyForProvider } from "./api-key-resolver.js";
+import { LLM_PROVIDERS } from "@dexto/core";
+import { getDextoEnvPath } from "./path.js";
+import { updateEnvFile } from "./env-file.js";
+async function saveProviderApiKey(provider, apiKey, startPath) {
+  if (!provider) throw new Error("provider is required");
+  if (!apiKey || !apiKey.trim()) throw new Error("apiKey is required");
+  const envVar = getPrimaryApiKeyEnvVar(provider);
+  const targetEnvPath = getDextoEnvPath(startPath);
+  await updateEnvFile(targetEnvPath, { [envVar]: apiKey });
+  process.env[envVar] = apiKey;
+  return { envVar, targetEnvPath };
+}
+function getProviderKeyStatus(provider) {
+  const envVar = getPrimaryApiKeyEnvVar(provider);
+  const key = resolveApiKeyForProvider(provider);
+  return { hasApiKey: Boolean(key && key.trim()), envVar };
+}
+function listProviderKeyStatus() {
+  const result = {};
+  for (const provider of LLM_PROVIDERS) {
+    result[provider] = getProviderKeyStatus(provider);
+  }
+  return result;
+}
+export {
+  getProviderKeyStatus,
+  listProviderKeyStatus,
+  saveProviderApiKey
+};

package/dist/utils/env-file.cjs

@@ -0,0 +1,118 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var env_file_exports = {};
+__export(env_file_exports, {
+  updateEnvFile: () => updateEnvFile
+});
+module.exports = __toCommonJS(env_file_exports);
+var path = __toESM(require("node:path"), 1);
+var import_node_fs = require("node:fs");
+const DEXTO_ENV_KEYS = [
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "GROQ_API_KEY",
+  "COHERE_API_KEY",
+  "XAI_API_KEY",
+  "DEXTO_LOG_LEVEL"
+];
+function isDextoEnvKey(value) {
+  return DEXTO_ENV_KEYS.includes(value);
+}
+async function updateEnvFile(envFilePath, updates) {
+  await import_node_fs.promises.mkdir(path.dirname(envFilePath), { recursive: true });
+  let envLines = [];
+  try {
+    const existingEnv = await import_node_fs.promises.readFile(envFilePath, "utf8");
+    envLines = existingEnv.split("\n");
+  } catch {
+  }
+  const currentValues = {};
+  envLines.forEach((line) => {
+    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (match && match[1] && isDextoEnvKey(match[1])) {
+      const value = match[2] ?? "";
+      currentValues[match[1]] = value;
+    }
+  });
+  const updatedValues = Object.fromEntries(
+    DEXTO_ENV_KEYS.map((key) => {
+      const update = updates[key];
+      const current = currentValues[key];
+      const fallback = key === "DEXTO_LOG_LEVEL" ? "info" : "";
+      const value = update !== void 0 ? update : current ?? fallback;
+      return [key, value];
+    })
+  );
+  const sectionHeader = "## Dexto env variables";
+  const headerIndex = envLines.findIndex((line) => line.trim() === sectionHeader);
+  let contentLines;
+  if (headerIndex !== -1) {
+    const beforeSection = envLines.slice(0, headerIndex);
+    let sectionEnd = headerIndex + 1;
+    while (sectionEnd < envLines.length && envLines[sectionEnd]?.trim() !== "") {
+      sectionEnd++;
+    }
+    if (sectionEnd < envLines.length && envLines[sectionEnd]?.trim() === "") {
+      sectionEnd++;
+    }
+    const afterSection = envLines.slice(sectionEnd);
+    contentLines = [...beforeSection, ...afterSection];
+  } else {
+    contentLines = envLines;
+  }
+  const existingEnvVars = {};
+  contentLines.forEach((line) => {
+    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (match && match[1] && isDextoEnvKey(match[1])) {
+      const value = match[2] ?? "";
+      existingEnvVars[match[1]] = value;
+    }
+  });
+  if (contentLines.length > 0) {
+    if (contentLines[contentLines.length - 1]?.trim() !== "") {
+      contentLines.push("");
+    }
+  } else {
+    contentLines.push("");
+  }
+  contentLines.push(sectionHeader);
+  for (const key of DEXTO_ENV_KEYS) {
+    if (key in existingEnvVars && !(key in updates)) {
+      continue;
+    }
+    contentLines.push(`${key}=${updatedValues[key]}`);
+  }
+  contentLines.push("");
+  await import_node_fs.promises.writeFile(envFilePath, contentLines.join("\n"), "utf8");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  updateEnvFile
+});

package/dist/utils/env-file.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Update a .env file with Dexto environment variables, ensuring our section stays consistent.
+ */
+export declare function updateEnvFile(envFilePath: string, updates: Record<string, string>): Promise<void>;
+//# sourceMappingURL=env-file.d.ts.map

package/dist/utils/env-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-file.d.ts","sourceRoot":"","sources":["../../src/utils/env-file.ts"],"names":[],"mappings":"AAsBA;;GAEG;AACH,wBAAsB,aAAa,CAC/B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,OAAO,CAAC,IAAI,CAAC,CAgFf"}

package/dist/utils/env-file.js

@@ -0,0 +1,84 @@
+import * as path from "node:path";
+import { promises as fs } from "node:fs";
+const DEXTO_ENV_KEYS = [
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "GROQ_API_KEY",
+  "COHERE_API_KEY",
+  "XAI_API_KEY",
+  "DEXTO_LOG_LEVEL"
+];
+function isDextoEnvKey(value) {
+  return DEXTO_ENV_KEYS.includes(value);
+}
+async function updateEnvFile(envFilePath, updates) {
+  await fs.mkdir(path.dirname(envFilePath), { recursive: true });
+  let envLines = [];
+  try {
+    const existingEnv = await fs.readFile(envFilePath, "utf8");
+    envLines = existingEnv.split("\n");
+  } catch {
+  }
+  const currentValues = {};
+  envLines.forEach((line) => {
+    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (match && match[1] && isDextoEnvKey(match[1])) {
+      const value = match[2] ?? "";
+      currentValues[match[1]] = value;
+    }
+  });
+  const updatedValues = Object.fromEntries(
+    DEXTO_ENV_KEYS.map((key) => {
+      const update = updates[key];
+      const current = currentValues[key];
+      const fallback = key === "DEXTO_LOG_LEVEL" ? "info" : "";
+      const value = update !== void 0 ? update : current ?? fallback;
+      return [key, value];
+    })
+  );
+  const sectionHeader = "## Dexto env variables";
+  const headerIndex = envLines.findIndex((line) => line.trim() === sectionHeader);
+  let contentLines;
+  if (headerIndex !== -1) {
+    const beforeSection = envLines.slice(0, headerIndex);
+    let sectionEnd = headerIndex + 1;
+    while (sectionEnd < envLines.length && envLines[sectionEnd]?.trim() !== "") {
+      sectionEnd++;
+    }
+    if (sectionEnd < envLines.length && envLines[sectionEnd]?.trim() === "") {
+      sectionEnd++;
+    }
+    const afterSection = envLines.slice(sectionEnd);
+    contentLines = [...beforeSection, ...afterSection];
+  } else {
+    contentLines = envLines;
+  }
+  const existingEnvVars = {};
+  contentLines.forEach((line) => {
+    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
+    if (match && match[1] && isDextoEnvKey(match[1])) {
+      const value = match[2] ?? "";
+      existingEnvVars[match[1]] = value;
+    }
+  });
+  if (contentLines.length > 0) {
+    if (contentLines[contentLines.length - 1]?.trim() !== "") {
+      contentLines.push("");
+    }
+  } else {
+    contentLines.push("");
+  }
+  contentLines.push(sectionHeader);
+  for (const key of DEXTO_ENV_KEYS) {
+    if (key in existingEnvVars && !(key in updates)) {
+      continue;
+    }
+    contentLines.push(`${key}=${updatedValues[key]}`);
+  }
+  contentLines.push("");
+  await fs.writeFile(envFilePath, contentLines.join("\n"), "utf8");
+}
+export {
+  updateEnvFile
+};

package/dist/utils/execution-context.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var execution_context_exports = {};
+__export(execution_context_exports, {
+  findDextoProjectRoot: () => findDextoProjectRoot,
+  findDextoSourceRoot: () => findDextoSourceRoot,
+  getExecutionContext: () => getExecutionContext
+});
+module.exports = __toCommonJS(execution_context_exports);
+var import_fs_walk = require("./fs-walk.js");
+var import_fs = require("fs");
+var path = __toESM(require("path"), 1);
+function isDextoSourceDirectory(dirPath) {
+  const packageJsonPath = path.join(dirPath, "package.json");
+  try {
+    const pkg = JSON.parse((0, import_fs.readFileSync)(packageJsonPath, "utf-8"));
+    return pkg.name === "dexto-monorepo";
+  } catch {
+    return false;
+  }
+}
+function isDextoProjectDirectory(dirPath) {
+  const packageJsonPath = path.join(dirPath, "package.json");
+  try {
+    const pkg = JSON.parse((0, import_fs.readFileSync)(packageJsonPath, "utf-8"));
+    if (pkg.name === "dexto" || pkg.name === "@dexto/core" || pkg.name === "@dexto/webui") {
+      return false;
+    }
+    const allDeps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {},
+      ...pkg.peerDependencies ?? {}
+    };
+    return "dexto" in allDeps || "@dexto/core" in allDeps;
+  } catch {
+    return false;
+  }
+}
+function findDextoSourceRoot(startPath = process.cwd()) {
+  return (0, import_fs_walk.walkUpDirectories)(startPath, isDextoSourceDirectory);
+}
+function findDextoProjectRoot(startPath = process.cwd()) {
+  return (0, import_fs_walk.walkUpDirectories)(startPath, isDextoProjectDirectory);
+}
+function getExecutionContext(startPath = process.cwd()) {
+  if (findDextoSourceRoot(startPath)) {
+    return "dexto-source";
+  }
+  if (findDextoProjectRoot(startPath)) {
+    return "dexto-project";
+  }
+  return "global-cli";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findDextoProjectRoot,
+  findDextoSourceRoot,
+  getExecutionContext
+});

package/dist/utils/execution-context.d.ts

@@ -0,0 +1,20 @@
+export type ExecutionContext = 'dexto-source' | 'dexto-project' | 'global-cli';
+/**
+ * Find dexto source root directory
+ * @param startPath Starting directory path
+ * @returns Dexto source root directory or null if not found
+ */
+export declare function findDextoSourceRoot(startPath?: string): string | null;
+/**
+ * Find dexto project root directory (projects using dexto as dependency)
+ * @param startPath Starting directory path
+ * @returns Dexto project root directory or null if not found
+ */
+export declare function findDextoProjectRoot(startPath?: string): string | null;
+/**
+ * Detect current execution context - standardized across codebase
+ * @param startPath Starting directory path (defaults to process.cwd())
+ * @returns Execution context
+ */
+export declare function getExecutionContext(startPath?: string): ExecutionContext;
+//# sourceMappingURL=execution-context.d.ts.map

package/dist/utils/execution-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-context.d.ts","sourceRoot":"","sources":["../../src/utils/execution-context.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,gBAAgB,GAAG,cAAc,GAAG,eAAe,GAAG,YAAY,CAAC;AAgD/E;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAEpF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAErF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,GAAE,MAAsB,GAAG,gBAAgB,CAavF"}

package/dist/utils/execution-context.js

@@ -0,0 +1,49 @@
+import { walkUpDirectories } from "./fs-walk.js";
+import { readFileSync } from "fs";
+import * as path from "path";
+function isDextoSourceDirectory(dirPath) {
+  const packageJsonPath = path.join(dirPath, "package.json");
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return pkg.name === "dexto-monorepo";
+  } catch {
+    return false;
+  }
+}
+function isDextoProjectDirectory(dirPath) {
+  const packageJsonPath = path.join(dirPath, "package.json");
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    if (pkg.name === "dexto" || pkg.name === "@dexto/core" || pkg.name === "@dexto/webui") {
+      return false;
+    }
+    const allDeps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {},
+      ...pkg.peerDependencies ?? {}
+    };
+    return "dexto" in allDeps || "@dexto/core" in allDeps;
+  } catch {
+    return false;
+  }
+}
+function findDextoSourceRoot(startPath = process.cwd()) {
+  return walkUpDirectories(startPath, isDextoSourceDirectory);
+}
+function findDextoProjectRoot(startPath = process.cwd()) {
+  return walkUpDirectories(startPath, isDextoProjectDirectory);
+}
+function getExecutionContext(startPath = process.cwd()) {
+  if (findDextoSourceRoot(startPath)) {
+    return "dexto-source";
+  }
+  if (findDextoProjectRoot(startPath)) {
+    return "dexto-project";
+  }
+  return "global-cli";
+}
+export {
+  findDextoProjectRoot,
+  findDextoSourceRoot,
+  getExecutionContext
+};

package/dist/utils/fs-walk.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fs_walk_exports = {};
+__export(fs_walk_exports, {
+  walkUpDirectories: () => walkUpDirectories
+});
+module.exports = __toCommonJS(fs_walk_exports);
+var path = __toESM(require("path"), 1);
+function walkUpDirectories(startPath, predicate) {
+  let currentPath = path.resolve(startPath);
+  const rootPath = path.parse(currentPath).root;
+  while (true) {
+    if (predicate(currentPath)) {
+      return currentPath;
+    }
+    if (currentPath === rootPath) break;
+    const parent = path.dirname(currentPath);
+    if (parent === currentPath) break;
+    currentPath = parent;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  walkUpDirectories
+});

package/dist/utils/fs-walk.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generic directory walker that searches up the directory tree
+ * @param startPath Starting directory path
+ * @param predicate Function that returns true when the desired condition is found
+ * @returns The directory path where the condition was met, or null if not found
+ */
+export declare function walkUpDirectories(startPath: string, predicate: (dirPath: string) => boolean): string | null;
+//# sourceMappingURL=fs-walk.d.ts.map