dexto 1.0.2 → 1.1.0

package/dist/src/app/chunk-DYNVXGAH.js

@@ -0,0 +1,137 @@
+import {
+  DextoRuntimeError
+} from "./chunk-Y33BS5SA.js";
+
+// src/core/agent/registry/errors.ts
+var RegistryError = class {
+  // Agent lookup errors
+  static agentNotFound(agentName, availableAgents) {
+    return new DextoRuntimeError(
+      "registry_agent_not_found" /* AGENT_NOT_FOUND */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "user" /* USER */,
+      `Agent '${agentName}' not found in registry`,
+      { agentName, availableAgents },
+      `Available agents: ${availableAgents.join(", ")}. Use a file path for custom agents.`
+    );
+  }
+  static agentInvalidEntry(agentName, reason) {
+    return new DextoRuntimeError(
+      "registry_agent_invalid_entry" /* AGENT_INVALID_ENTRY */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Registry entry for '${agentName}' is invalid: ${reason}`,
+      { agentName, reason },
+      "This indicates a problem with the agent registry - please report this issue"
+    );
+  }
+  // Installation errors
+  static installationFailed(agentName, cause) {
+    return new DextoRuntimeError(
+      "registry_installation_failed" /* INSTALLATION_FAILED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Failed to install agent '${agentName}': ${cause}`,
+      { agentName, cause },
+      "Check network connection and available disk space"
+    );
+  }
+  static installationValidationFailed(agentName, missingPath) {
+    return new DextoRuntimeError(
+      "registry_installation_validation_failed" /* INSTALLATION_VALIDATION_FAILED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Installation validation failed for '${agentName}': missing main config`,
+      { agentName, missingPath },
+      "This indicates a problem with the agent bundle - please report this issue"
+    );
+  }
+  // Config file errors
+  static configNotFound(configPath) {
+    return new DextoRuntimeError(
+      "registry_config_not_found" /* CONFIG_NOT_FOUND */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Agent config file not found: ${configPath}`,
+      { configPath },
+      "This indicates a problem with the agent installation"
+    );
+  }
+  static mainConfigMissing(agentName, expectedPath) {
+    return new DextoRuntimeError(
+      "registry_main_config_missing" /* MAIN_CONFIG_MISSING */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Main config file not found for agent '${agentName}': ${expectedPath}`,
+      { agentName, expectedPath },
+      "This indicates a problem with the agent bundle structure"
+    );
+  }
+  // Uninstallation errors
+  static agentNotInstalled(agentName) {
+    return new DextoRuntimeError(
+      "registry_agent_not_installed" /* AGENT_NOT_INSTALLED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "user" /* USER */,
+      `Agent '${agentName}' is not installed`,
+      { agentName },
+      'Use "dexto list-agents --installed" to see installed agents'
+    );
+  }
+  static agentProtected(agentName) {
+    return new DextoRuntimeError(
+      "registry_agent_protected" /* AGENT_PROTECTED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "user" /* USER */,
+      `Agent '${agentName}' is protected and cannot be uninstalled. Use --force to override (not recommended for critical agents)`,
+      { agentName },
+      "Use --force to override (not recommended for critical agents)"
+    );
+  }
+  static uninstallationFailed(agentName, cause) {
+    return new DextoRuntimeError(
+      "registry_uninstallation_failed" /* UNINSTALLATION_FAILED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Failed to uninstall agent '${agentName}': ${cause}`,
+      { agentName, cause },
+      "Check file permissions and ensure no processes are using the agent"
+    );
+  }
+  // Registry file errors
+  static registryNotFound(registryPath) {
+    return new DextoRuntimeError(
+      "registry_file_not_found" /* REGISTRY_NOT_FOUND */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Agent registry not found: ${registryPath}`,
+      { registryPath },
+      "This indicates a problem with the Dexto installation - please reinstall or report this issue"
+    );
+  }
+  static registryParseError(registryPath, cause) {
+    return new DextoRuntimeError(
+      "registry_parse_error" /* REGISTRY_PARSE_ERROR */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "system" /* SYSTEM */,
+      `Failed to parse agent registry from ${registryPath}: ${cause}`,
+      { registryPath, cause },
+      "This indicates a corrupted registry file - please reinstall Dexto"
+    );
+  }
+  // Auto-install control errors
+  static agentNotInstalledAutoInstallDisabled(agentName, availableAgents) {
+    return new DextoRuntimeError(
+      "registry_agent_not_installed_auto_install_disabled" /* AGENT_NOT_INSTALLED_AUTO_INSTALL_DISABLED */,
+      "agent_registry" /* AGENT_REGISTRY */,
+      "user" /* USER */,
+      `Agent '${agentName}' is not installed locally and auto-install is disabled`,
+      { agentName, availableAgents },
+      `Use 'dexto install ${agentName}' to install it manually, or use a file path for custom agents`
+    );
+  }
+};
+
+export {
+  RegistryError
+};

package/dist/src/app/chunk-PW2PHCHR.js

@@ -0,0 +1,83 @@
+import {
+  DextoRuntimeError
+} from "./chunk-Y33BS5SA.js";
+
+// src/core/storage/errors.ts
+var StorageError = class {
+  /**
+   * Connection failed error
+   */
+  static connectionFailed(reason, config) {
+    return new DextoRuntimeError(
+      "storage_connection_failed" /* CONNECTION_FAILED */,
+      "storage" /* STORAGE */,
+      "third_party" /* THIRD_PARTY */,
+      `Storage connection failed: ${reason}`,
+      { reason, config }
+    );
+  }
+  /**
+   * Backend not connected error
+   */
+  static notConnected(backendType) {
+    return new DextoRuntimeError(
+      "storage_connection_failed" /* CONNECTION_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `${backendType} not connected`,
+      { backendType }
+    );
+  }
+  /**
+   * Read operation failed
+   */
+  static readFailed(operation, reason, details) {
+    return new DextoRuntimeError(
+      "storage_read_failed" /* READ_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `Storage read failed for ${operation}: ${reason}`,
+      { operation, reason, ...details }
+    );
+  }
+  /**
+   * Write operation failed
+   */
+  static writeFailed(operation, reason, details) {
+    return new DextoRuntimeError(
+      "storage_write_failed" /* WRITE_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `Storage write failed for ${operation}: ${reason}`,
+      { operation, reason, ...details }
+    );
+  }
+  /**
+   * Delete operation failed
+   */
+  static deleteFailed(operation, reason, details) {
+    return new DextoRuntimeError(
+      "storage_delete_failed" /* DELETE_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `Storage delete failed for ${operation}: ${reason}`,
+      { operation, reason, ...details }
+    );
+  }
+  /**
+   * Migration failed error
+   */
+  static migrationFailed(reason, details) {
+    return new DextoRuntimeError(
+      "storage_migration_failed" /* MIGRATION_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `Database migration failed: ${reason}`,
+      { reason, ...details }
+    );
+  }
+};
+
+export {
+  StorageError
+};

package/dist/src/app/chunk-R4Q522DR.js

@@ -0,0 +1,205 @@
+import {
+  LLM_PROVIDERS,
+  NonEmptyTrimmed,
+  getDextoGlobalPath,
+  getSupportedModels,
+  isValidProviderModel,
+  logger
+} from "./chunk-CLDYRNV6.js";
+import {
+  DextoValidationError
+} from "./chunk-X6LEX724.js";
+import {
+  DextoRuntimeError
+} from "./chunk-Y33BS5SA.js";
+
+// src/core/preferences/loader.ts
+import { existsSync } from "fs";
+import { promises as fs } from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+
+// src/core/preferences/schemas.ts
+import { z } from "zod";
+var PreferenceLLMSchema = z.object({
+  provider: z.enum(LLM_PROVIDERS).describe("LLM provider (openai, anthropic, google, etc.)"),
+  model: NonEmptyTrimmed.describe("Model name for the provider"),
+  apiKey: z.string().regex(
+    /^\$[A-Z_][A-Z0-9_]*$/,
+    "Must be environment variable reference (e.g., $OPENAI_API_KEY)"
+  ).describe("Environment variable reference for API key")
+}).strict().superRefine((data, ctx) => {
+  if (!isValidProviderModel(data.provider, data.model)) {
+    const supportedModels = getSupportedModels(data.provider);
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["model"],
+      message: `Model '${data.model}' is not supported by provider '${data.provider}'. Supported models: ${supportedModels.join(", ")}`,
+      params: {
+        code: "preference_model_incompatible" /* MODEL_INCOMPATIBLE */,
+        scope: "preference" /* PREFERENCE */,
+        type: "user" /* USER */
+      }
+    });
+  }
+});
+var PreferenceDefaultsSchema = z.object({
+  defaultAgent: z.string().min(1).describe("Default agent name for global CLI usage (required)")
+}).strict();
+var PreferenceSetupSchema = z.object({
+  completed: z.boolean().default(false).describe("Whether initial setup has been completed")
+}).strict();
+var GlobalPreferencesSchema = z.object({
+  llm: PreferenceLLMSchema.describe("LLM configuration preferences"),
+  defaults: PreferenceDefaultsSchema.describe("Default behavior preferences (required)"),
+  setup: PreferenceSetupSchema.default({ completed: false }).describe(
+    "Setup completion tracking"
+  )
+}).strict();
+
+// src/core/preferences/constants.ts
+var PREFERENCES_FILE = "preferences.yml";
+
+// src/core/preferences/errors.ts
+var PreferenceError = class {
+  static fileNotFound(preferencesPath) {
+    return new DextoRuntimeError(
+      "preference_file_not_found" /* FILE_NOT_FOUND */,
+      "preference" /* PREFERENCE */,
+      "user" /* USER */,
+      `Preferences file not found: ${preferencesPath}`,
+      { preferencesPath },
+      "Run `dexto setup` to create preferences"
+    );
+  }
+  static fileReadError(preferencesPath, cause) {
+    return new DextoRuntimeError(
+      "preference_file_read_error" /* FILE_READ_ERROR */,
+      "preference" /* PREFERENCE */,
+      "system" /* SYSTEM */,
+      `Failed to read preferences: ${cause}`,
+      { preferencesPath, cause },
+      "Check file permissions and ensure the file is not corrupted"
+    );
+  }
+  static fileWriteError(preferencesPath, cause) {
+    return new DextoRuntimeError(
+      "preference_file_write_error" /* FILE_WRITE_ERROR */,
+      "preference" /* PREFERENCE */,
+      "system" /* SYSTEM */,
+      `Failed to save preferences: ${cause}`,
+      { preferencesPath, cause },
+      "Check file permissions and available disk space"
+    );
+  }
+  static validationFailed(zodError) {
+    const issues = zodError.issues.map((issue) => ({
+      code: "preference_validation_error" /* VALIDATION_ERROR */,
+      message: `${issue.path.join(".")}: ${issue.message}`,
+      scope: "preference" /* PREFERENCE */,
+      type: "user" /* USER */,
+      severity: "error"
+    }));
+    return new DextoValidationError(issues);
+  }
+};
+
+// src/core/preferences/loader.ts
+async function loadGlobalPreferences() {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  if (!existsSync(preferencesPath)) {
+    throw PreferenceError.fileNotFound(preferencesPath);
+  }
+  try {
+    const fileContent = await fs.readFile(preferencesPath, "utf-8");
+    const rawPreferences = parseYaml(fileContent);
+    const validation = GlobalPreferencesSchema.safeParse(rawPreferences);
+    if (!validation.success) {
+      throw PreferenceError.validationFailed(validation.error);
+    }
+    logger.debug(`Loaded global preferences from: ${preferencesPath}`);
+    return validation.data;
+  } catch (error) {
+    if (error instanceof DextoValidationError || error instanceof DextoRuntimeError) {
+      throw error;
+    }
+    throw PreferenceError.fileReadError(
+      preferencesPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function saveGlobalPreferences(preferences) {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  const validation = GlobalPreferencesSchema.safeParse(preferences);
+  if (!validation.success) {
+    throw PreferenceError.validationFailed(validation.error);
+  }
+  try {
+    logger.info(`Saving global preferences to: ${preferencesPath}`);
+    const dextoDir = getDextoGlobalPath("");
+    await fs.mkdir(dextoDir, { recursive: true });
+    const yamlContent = stringifyYaml(preferences, {
+      indent: 2,
+      lineWidth: 100,
+      minContentWidth: 20
+    });
+    await fs.writeFile(preferencesPath, yamlContent, "utf-8");
+    logger.info(
+      `\u2713 Saved global preferences ${JSON.stringify(preferences)} to: ${preferencesPath}`
+    );
+  } catch (error) {
+    throw PreferenceError.fileWriteError(
+      preferencesPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function globalPreferencesExist() {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  return existsSync(preferencesPath);
+}
+function getGlobalPreferencesPath() {
+  return getDextoGlobalPath(PREFERENCES_FILE);
+}
+function createInitialPreferences(provider, model, apiKeyVar, defaultAgent = "default-agent") {
+  return {
+    llm: {
+      provider,
+      model,
+      apiKey: `$${apiKeyVar}`
+    },
+    defaults: {
+      defaultAgent
+    },
+    setup: {
+      completed: true
+    }
+  };
+}
+async function updateGlobalPreferences(updates) {
+  const existing = await loadGlobalPreferences();
+  const merged = {
+    ...existing,
+    ...updates,
+    // LLM section requires complete replacement (high coherence - provider/model/apiKey must match)
+    llm: updates.llm || existing.llm,
+    // Defaults and setup sections allow partial updates (low coherence - independent fields)
+    defaults: updates.defaults ? { ...existing.defaults, ...updates.defaults } : existing.defaults,
+    setup: updates.setup ? { ...existing.setup, ...updates.setup } : existing.setup
+  };
+  const validation = GlobalPreferencesSchema.safeParse(merged);
+  if (!validation.success) {
+    throw PreferenceError.validationFailed(validation.error);
+  }
+  await saveGlobalPreferences(validation.data);
+  return validation.data;
+}
+
+export {
+  loadGlobalPreferences,
+  saveGlobalPreferences,
+  globalPreferencesExist,
+  getGlobalPreferencesPath,
+  createInitialPreferences,
+  updateGlobalPreferences
+};

package/dist/src/app/chunk-UXCBS3TR.js

@@ -0,0 +1,281 @@
+import {
+  loadGlobalPreferences
+} from "./chunk-R4Q522DR.js";
+import {
+  copyDirectory,
+  getDextoGlobalPath,
+  logger,
+  resolveBundledScript,
+  writePreferencesToAgent
+} from "./chunk-CLDYRNV6.js";
+import {
+  RegistryError
+} from "./chunk-DYNVXGAH.js";
+
+// src/core/agent/registry/registry.ts
+import { existsSync, readFileSync } from "fs";
+import { promises as fs } from "fs";
+import path from "path";
+
+// src/core/agent/registry/types.ts
+import { z } from "zod";
+var AgentRegistryEntrySchema = z.object({
+  description: z.string(),
+  author: z.string(),
+  tags: z.array(z.string()),
+  source: z.string(),
+  main: z.string().optional()
+}).strict();
+var RegistrySchema = z.object({
+  version: z.string(),
+  agents: z.record(z.string(), AgentRegistryEntrySchema)
+}).strict();
+
+// src/core/agent/registry/registry.ts
+var cachedRegistry = null;
+var LocalAgentRegistry = class {
+  _registry = null;
+  /**
+   * Lazy load registry from JSON file
+   */
+  getRegistry() {
+    if (this._registry === null) {
+      this._registry = this.loadRegistry();
+    }
+    return this._registry;
+  }
+  /**
+   * Load registry from bundled JSON file
+   * Uses fail-fast approach - throws RegistryError for any loading issues
+   */
+  loadRegistry() {
+    let jsonPath;
+    try {
+      jsonPath = resolveBundledScript("agents/agent-registry.json");
+    } catch (_error) {
+      throw RegistryError.registryNotFound(
+        "agents/agent-registry.json (bundle resolution failed)"
+      );
+    }
+    if (!existsSync(jsonPath)) {
+      throw RegistryError.registryNotFound(jsonPath);
+    }
+    try {
+      const jsonData = readFileSync(jsonPath, "utf-8");
+      const rawRegistry = JSON.parse(jsonData);
+      return RegistrySchema.parse(rawRegistry);
+    } catch (error) {
+      throw RegistryError.registryParseError(
+        jsonPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Check if agent exists in registry
+   */
+  hasAgent(name) {
+    const registry = this.getRegistry();
+    return name in registry.agents;
+  }
+  /**
+   * Get available agents with their metadata from registry
+   */
+  getAvailableAgents() {
+    const registry = this.getRegistry();
+    return registry.agents;
+  }
+  /**
+   * Resolve main config file for installed agent
+   * Handles both directory agents (with main field) and single-file agents
+   */
+  resolveMainConfig(agentDir, agentName) {
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentName];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw RegistryError.agentNotFound(agentName, available);
+    }
+    if (agentData.source.endsWith("/")) {
+      if (!agentData.main) {
+        throw RegistryError.agentInvalidEntry(
+          agentName,
+          "directory entry missing main field"
+        );
+      }
+      const mainConfigPath = path.join(agentDir, agentData.main);
+      if (!existsSync(mainConfigPath)) {
+        throw RegistryError.mainConfigMissing(agentName, mainConfigPath);
+      }
+      return mainConfigPath;
+    } else {
+      const filename = path.basename(agentData.source);
+      const configPath = path.join(agentDir, filename);
+      if (!existsSync(configPath)) {
+        throw RegistryError.configNotFound(configPath);
+      }
+      return configPath;
+    }
+  }
+  /**
+   * Install agent atomically using temp + rename pattern
+   * @param agentName Name of the agent to install
+   * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
+   */
+  async installAgent(agentName, injectPreferences = true) {
+    logger.info(`Installing agent: ${agentName}`);
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentName];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw RegistryError.agentNotFound(agentName, available);
+    }
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const targetDir = path.join(globalAgentsDir, agentName);
+    if (existsSync(targetDir)) {
+      logger.info(`Agent '${agentName}' already installed`);
+      return this.resolveMainConfig(targetDir, agentName);
+    }
+    await fs.mkdir(globalAgentsDir, { recursive: true });
+    const sourcePath = resolveBundledScript(`agents/${agentData.source}`);
+    const tempDir = `${targetDir}.tmp.${Date.now()}`;
+    try {
+      if (agentData.source.endsWith("/")) {
+        await copyDirectory(sourcePath, tempDir);
+      } else {
+        await fs.mkdir(tempDir, { recursive: true });
+        const targetFile = path.join(tempDir, path.basename(sourcePath));
+        await fs.copyFile(sourcePath, targetFile);
+      }
+      const mainConfigPath = this.resolveMainConfig(tempDir, agentName);
+      if (!existsSync(mainConfigPath)) {
+        throw RegistryError.installationValidationFailed(agentName, mainConfigPath);
+      }
+      await fs.rename(tempDir, targetDir);
+      logger.info(`\u2713 Installed agent '${agentName}' to ${targetDir}`);
+      if (injectPreferences) {
+        try {
+          const preferences = await loadGlobalPreferences();
+          await writePreferencesToAgent(targetDir, preferences);
+          logger.info(`\u2713 Applied global preferences to installed agent '${agentName}'`);
+        } catch (error) {
+          logger.warn(
+            `Failed to inject preferences to '${agentName}': ${error instanceof Error ? error.message : String(error)}`
+          );
+          console.log(
+            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentName}' - agent will use bundled settings`
+          );
+        }
+      } else {
+        logger.info(
+          `Skipped preference injection for '${agentName}' (injectPreferences=false)`
+        );
+      }
+      return this.resolveMainConfig(targetDir, agentName);
+    } catch (error) {
+      try {
+        if (existsSync(tempDir)) {
+          await fs.rm(tempDir, { recursive: true, force: true });
+        }
+      } catch (cleanupError) {
+        logger.error(
+          `Failed to clean up temp directory: ${cleanupError}. Skipping cleanup...`
+        );
+      }
+      throw RegistryError.installationFailed(
+        agentName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Resolve a registry agent name to a config path
+   * NOTE: Only handles registry names, not file paths (routing done in loadAgentConfig)
+   * Handles installing agent if needed
+   * @param agentName Name of the agent to resolve
+   * @param autoInstall Whether to automatically install missing agents from registry (default: true)
+   * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
+   */
+  async resolveAgent(agentName, autoInstall = true, injectPreferences = true) {
+    logger.debug(`Resolving registry agent: ${agentName}`);
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const installedPath = path.join(globalAgentsDir, agentName);
+    if (existsSync(installedPath)) {
+      const mainConfig = this.resolveMainConfig(installedPath, agentName);
+      logger.debug(`Resolved installed agent '${agentName}' to: ${mainConfig}`);
+      return mainConfig;
+    }
+    logger.debug(`Agent '${agentName}' not found in installed path: ${installedPath}`);
+    if (this.hasAgent(agentName)) {
+      if (autoInstall) {
+        logger.info(`Installing agent '${agentName}' from registry...`);
+        return await this.installAgent(agentName, injectPreferences);
+      } else {
+        const registry2 = this.getRegistry();
+        const available2 = Object.keys(registry2.agents);
+        throw RegistryError.agentNotInstalledAutoInstallDisabled(agentName, available2);
+      }
+    }
+    const registry = this.getRegistry();
+    const available = Object.keys(registry.agents);
+    throw RegistryError.agentNotFound(agentName, available);
+  }
+  /**
+   * Get list of currently installed agents
+   */
+  async getInstalledAgents() {
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    if (!existsSync(globalAgentsDir)) {
+      return [];
+    }
+    try {
+      const entries = await fs.readdir(globalAgentsDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".tmp") && !name.includes(".tmp."));
+    } catch (error) {
+      logger.error(`Failed to read installed agents directory: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Check if an agent is safe to uninstall (not the default-agent which is critical)
+   */
+  isAgentSafeToUninstall(agentName) {
+    return agentName !== "default-agent";
+  }
+  /**
+   * Uninstall an agent by removing its directory
+   * @param agentName Name of the agent to uninstall
+   * @param force Whether to force uninstall even if agent is protected (default: false)
+   */
+  async uninstallAgent(agentName, force = false) {
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const agentDir = path.join(globalAgentsDir, agentName);
+    logger.info(`Uninstalling agent: ${agentName} from ${agentDir}`);
+    if (!existsSync(agentDir)) {
+      throw RegistryError.agentNotInstalled(agentName);
+    }
+    if (!force && !this.isAgentSafeToUninstall(agentName)) {
+      throw RegistryError.agentProtected(agentName);
+    }
+    try {
+      await fs.rm(agentDir, { recursive: true, force: true });
+      logger.info(`\u2713 Removed agent '${agentName}' from ${agentDir}`);
+    } catch (error) {
+      throw RegistryError.uninstallationFailed(
+        agentName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+};
+function getAgentRegistry() {
+  if (cachedRegistry === null) {
+    cachedRegistry = new LocalAgentRegistry();
+  }
+  return cachedRegistry;
+}
+
+export {
+  LocalAgentRegistry,
+  getAgentRegistry
+};