@dexto/core 1.5.4 → 1.5.6

package/dist/filesystem/filesystem-service.js

@@ -1,501 +0,0 @@
-import "../chunk-PTJYTZNU.js";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { glob } from "glob";
-import { getDextoPath } from "../utils/path.js";
-import { PathValidator } from "./path-validator.js";
-import { FileSystemError } from "./errors.js";
-import { DextoLogComponent } from "../logger/v2/types.js";
-const DEFAULT_ENCODING = "utf-8";
-const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
-const DEFAULT_MAX_RESULTS = 1e3;
-const DEFAULT_MAX_SEARCH_RESULTS = 100;
-class FileSystemService {
-  config;
-  pathValidator;
-  initialized = false;
-  logger;
-  constructor(config = {}, logger) {
-    this.config = {
-      allowedPaths: config.allowedPaths || ["."],
-      blockedPaths: config.blockedPaths || [".git", "node_modules/.bin", ".env"],
-      blockedExtensions: config.blockedExtensions || [".exe", ".dll", ".so"],
-      maxFileSize: config.maxFileSize || DEFAULT_MAX_FILE_SIZE,
-      enableBackups: config.enableBackups ?? false,
-      backupPath: config.backupPath,
-      // Optional absolute override, defaults handled by getBackupDir()
-      backupRetentionDays: config.backupRetentionDays || 7,
-      workingDirectory: config.workingDirectory
-    };
-    this.logger = logger.createChild(DextoLogComponent.FILESYSTEM);
-    this.pathValidator = new PathValidator(this.config, this.logger);
-  }
-  /**
-   * Get backup directory path (context-aware with optional override)
-   * TODO: Migrate to explicit configuration via CLI enrichment layer (per-agent paths)
-   */
-  getBackupDir() {
-    return this.config.backupPath || getDextoPath("backups");
-  }
-  /**
-   * Initialize the service
-   */
-  async initialize() {
-    if (this.initialized) {
-      this.logger.debug("FileSystemService already initialized");
-      return;
-    }
-    if (this.config.enableBackups) {
-      try {
-        const backupDir = this.getBackupDir();
-        await fs.mkdir(backupDir, { recursive: true });
-        this.logger.debug(`Backup directory created/verified: ${backupDir}`);
-      } catch (error) {
-        this.logger.warn(
-          `Failed to create backup directory: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-    this.initialized = true;
-    this.logger.info("FileSystemService initialized successfully");
-  }
-  /**
-   * Check if a file path is within the configured allowed paths.
-   * This is a public method for external consumers (like ToolManager) to check
-   * if a path requires directory approval before file operations.
-   *
-   * @param filePath The file path to check (can be relative or absolute)
-   * @returns true if the path is within allowed paths, false otherwise
-   */
-  async isPathWithinAllowed(filePath) {
-    return this.pathValidator.isPathWithinAllowed(filePath);
-  }
-  /**
-   * Get the list of configured allowed paths.
-   * Useful for displaying to users when directory approval is needed.
-   *
-   * @returns Array of allowed path strings
-   */
-  getAllowedPaths() {
-    return this.pathValidator.getAllowedPaths();
-  }
-  /**
-   * Get the parent directory of a file path (resolved to absolute).
-   * Useful for directory approval requests.
-   *
-   * @param filePath The file path
-   * @returns The absolute parent directory path
-   */
-  getParentDirectory(filePath) {
-    return path.dirname(path.resolve(filePath));
-  }
-  /**
-   * Set a callback to check if a path is in an approved directory.
-   * This allows PathValidator to consult ApprovalManager without a direct dependency.
-   *
-   * @param checker Function that returns true if path is in an approved directory
-   */
-  setDirectoryApprovalChecker(checker) {
-    this.pathValidator.setDirectoryApprovalChecker(checker);
-  }
-  /**
-   * Read a file with validation and size limits
-   */
-  async readFile(filePath, options = {}) {
-    if (!this.initialized) {
-      throw FileSystemError.notInitialized();
-    }
-    const validation = await this.pathValidator.validatePath(filePath);
-    if (!validation.isValid || !validation.normalizedPath) {
-      throw FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
-    }
-    const normalizedPath = validation.normalizedPath;
-    try {
-      const stats = await fs.stat(normalizedPath);
-      if (!stats.isFile()) {
-        throw FileSystemError.invalidPath(normalizedPath, "Path is not a file");
-      }
-      if (stats.size > this.config.maxFileSize) {
-        throw FileSystemError.fileTooLarge(
-          normalizedPath,
-          stats.size,
-          this.config.maxFileSize
-        );
-      }
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        throw FileSystemError.fileNotFound(normalizedPath);
-      }
-      if (error.code === "EACCES") {
-        throw FileSystemError.permissionDenied(normalizedPath, "read");
-      }
-      throw FileSystemError.readFailed(
-        normalizedPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    try {
-      const encoding = options.encoding || DEFAULT_ENCODING;
-      const content = await fs.readFile(normalizedPath, encoding);
-      const lines = content.split("\n");
-      const limit = options.limit;
-      const offset1 = options.offset;
-      let selectedLines;
-      let truncated = false;
-      if (offset1 && offset1 > 0 || limit !== void 0) {
-        const start = offset1 && offset1 > 0 ? Math.max(0, offset1 - 1) : 0;
-        const end = limit !== void 0 ? start + limit : lines.length;
-        selectedLines = lines.slice(start, end);
-        truncated = end < lines.length;
-      } else {
-        selectedLines = lines;
-      }
-      return {
-        content: selectedLines.join("\n"),
-        lines: selectedLines.length,
-        encoding,
-        truncated,
-        size: Buffer.byteLength(content, encoding)
-      };
-    } catch (error) {
-      throw FileSystemError.readFailed(
-        normalizedPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Find files matching a glob pattern
-   */
-  async globFiles(pattern, options = {}) {
-    if (!this.initialized) {
-      throw FileSystemError.notInitialized();
-    }
-    const cwd = options.cwd || this.config.workingDirectory || process.cwd();
-    const maxResults = options.maxResults || DEFAULT_MAX_RESULTS;
-    try {
-      const files = await glob(pattern, {
-        cwd,
-        absolute: true,
-        nodir: true,
-        // Only files
-        follow: false
-        // Don't follow symlinks
-      });
-      const validFiles = [];
-      for (const file of files) {
-        const validation = await this.pathValidator.validatePath(file);
-        if (!validation.isValid || !validation.normalizedPath) {
-          this.logger.debug(`Skipping invalid path: ${file}`);
-          continue;
-        }
-        if (options.includeMetadata !== false) {
-          try {
-            const stats = await fs.stat(validation.normalizedPath);
-            validFiles.push({
-              path: validation.normalizedPath,
-              size: stats.size,
-              modified: stats.mtime,
-              isDirectory: stats.isDirectory()
-            });
-          } catch (error) {
-            this.logger.debug(
-              `Failed to stat file ${file}: ${error instanceof Error ? error.message : String(error)}`
-            );
-          }
-        } else {
-          validFiles.push({
-            path: validation.normalizedPath,
-            size: 0,
-            modified: /* @__PURE__ */ new Date(),
-            isDirectory: false
-          });
-        }
-        if (validFiles.length >= maxResults) {
-          break;
-        }
-      }
-      const limited = validFiles.length >= maxResults;
-      return {
-        files: validFiles,
-        truncated: limited,
-        totalFound: validFiles.length
-      };
-    } catch (error) {
-      throw FileSystemError.globFailed(
-        pattern,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Search for content in files (grep-like functionality)
-   */
-  async searchContent(pattern, options = {}) {
-    if (!this.initialized) {
-      throw FileSystemError.notInitialized();
-    }
-    const searchPath = options.path || this.config.workingDirectory || process.cwd();
-    const globPattern = options.glob || "**/*";
-    const maxResults = options.maxResults || DEFAULT_MAX_SEARCH_RESULTS;
-    const contextLines = options.contextLines || 0;
-    try {
-      const flags = options.caseInsensitive ? "i" : "";
-      const regex = new RegExp(pattern, flags);
-      const globResult = await this.globFiles(globPattern, {
-        cwd: searchPath,
-        maxResults: 1e4
-        // Search more files, but limit results
-      });
-      const matches = [];
-      let filesSearched = 0;
-      for (const fileInfo of globResult.files) {
-        try {
-          const fileContent = await this.readFile(fileInfo.path);
-          const lines = fileContent.content.split("\n");
-          filesSearched++;
-          for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (regex.test(line)) {
-              let context;
-              if (contextLines > 0) {
-                const before = [];
-                const after = [];
-                for (let j = Math.max(0, i - contextLines); j < i; j++) {
-                  before.push(lines[j]);
-                }
-                for (let j = i + 1; j < Math.min(lines.length, i + contextLines + 1); j++) {
-                  after.push(lines[j]);
-                }
-                context = { before, after };
-              }
-              matches.push({
-                file: fileInfo.path,
-                lineNumber: i + 1,
-                // 1-based line numbers
-                line,
-                ...context !== void 0 && { context }
-              });
-              if (matches.length >= maxResults) {
-                return {
-                  matches,
-                  totalMatches: matches.length,
-                  truncated: true,
-                  filesSearched
-                };
-              }
-            }
-          }
-        } catch (error) {
-          this.logger.debug(
-            `Skipping file ${fileInfo.path}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      return {
-        matches,
-        totalMatches: matches.length,
-        truncated: false,
-        filesSearched
-      };
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Invalid regular expression")) {
-        throw FileSystemError.invalidPattern(pattern, "Invalid regular expression syntax");
-      }
-      throw FileSystemError.searchFailed(
-        pattern,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Write content to a file
-   */
-  async writeFile(filePath, content, options = {}) {
-    if (!this.initialized) {
-      throw FileSystemError.notInitialized();
-    }
-    const validation = await this.pathValidator.validatePath(filePath);
-    if (!validation.isValid || !validation.normalizedPath) {
-      throw FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
-    }
-    const normalizedPath = validation.normalizedPath;
-    const encoding = options.encoding || DEFAULT_ENCODING;
-    let backupPath;
-    let fileExists = false;
-    try {
-      await fs.access(normalizedPath);
-      fileExists = true;
-    } catch {
-    }
-    if (fileExists && (options.backup ?? this.config.enableBackups)) {
-      backupPath = await this.createBackup(normalizedPath);
-    }
-    try {
-      if (options.createDirs) {
-        const dir = path.dirname(normalizedPath);
-        await fs.mkdir(dir, { recursive: true });
-      }
-      await fs.writeFile(normalizedPath, content, encoding);
-      const bytesWritten = Buffer.byteLength(content, encoding);
-      this.logger.debug(`File written: ${normalizedPath} (${bytesWritten} bytes)`);
-      return {
-        success: true,
-        path: normalizedPath,
-        bytesWritten,
-        backupPath
-      };
-    } catch (error) {
-      throw FileSystemError.writeFailed(
-        normalizedPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Edit a file by replacing text
-   */
-  async editFile(filePath, operation, options = {}) {
-    if (!this.initialized) {
-      throw FileSystemError.notInitialized();
-    }
-    const validation = await this.pathValidator.validatePath(filePath);
-    if (!validation.isValid || !validation.normalizedPath) {
-      throw FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
-    }
-    const normalizedPath = validation.normalizedPath;
-    const fileContent = await this.readFile(normalizedPath);
-    const originalContent = fileContent.content;
-    const occurrences = (originalContent.match(
-      new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")
-    ) || []).length;
-    if (occurrences === 0) {
-      throw FileSystemError.stringNotFound(normalizedPath, operation.oldString);
-    }
-    if (!operation.replaceAll && occurrences > 1) {
-      throw FileSystemError.stringNotUnique(normalizedPath, operation.oldString, occurrences);
-    }
-    let backupPath;
-    if (options.backup ?? this.config.enableBackups) {
-      backupPath = await this.createBackup(normalizedPath);
-    }
-    try {
-      let newContent;
-      if (operation.replaceAll) {
-        newContent = originalContent.replace(
-          new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
-          operation.newString
-        );
-      } else {
-        newContent = originalContent.replace(operation.oldString, operation.newString);
-      }
-      await fs.writeFile(normalizedPath, newContent, options.encoding || DEFAULT_ENCODING);
-      this.logger.debug(`File edited: ${normalizedPath} (${occurrences} replacements)`);
-      return {
-        success: true,
-        path: normalizedPath,
-        changesCount: occurrences,
-        backupPath,
-        originalContent,
-        newContent
-      };
-    } catch (error) {
-      throw FileSystemError.editFailed(
-        normalizedPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Create a backup of a file
-   */
-  async createBackup(filePath) {
-    const backupDir = this.getBackupDir();
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const basename = path.basename(filePath);
-    const backupFilename = `${basename}.${timestamp}.backup`;
-    const backupPath = path.join(backupDir, backupFilename);
-    try {
-      await fs.mkdir(backupDir, { recursive: true });
-      await fs.copyFile(filePath, backupPath);
-      this.logger.debug(`Backup created: ${backupPath}`);
-      await this.cleanupOldBackups();
-      return backupPath;
-    } catch (error) {
-      throw FileSystemError.backupFailed(
-        filePath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Clean up old backup files based on retention policy
-   */
-  async cleanupOldBackups() {
-    if (!this.config.enableBackups) {
-      return 0;
-    }
-    let backupDir;
-    try {
-      backupDir = this.getBackupDir();
-    } catch (error) {
-      this.logger.warn(
-        `Failed to resolve backup directory: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return 0;
-    }
-    try {
-      await fs.access(backupDir);
-    } catch {
-      return 0;
-    }
-    const cutoffDate = new Date(
-      Date.now() - this.config.backupRetentionDays * 24 * 60 * 60 * 1e3
-    );
-    let deletedCount = 0;
-    try {
-      const files = await fs.readdir(backupDir);
-      const backupFiles = files.filter((file) => file.endsWith(".backup"));
-      for (const file of backupFiles) {
-        const filePath = path.join(backupDir, file);
-        try {
-          const stats = await fs.stat(filePath);
-          if (stats.mtime < cutoffDate) {
-            await fs.unlink(filePath);
-            deletedCount++;
-            this.logger.debug(`Cleaned up old backup: ${file}`);
-          }
-        } catch (error) {
-          this.logger.warn(
-            `Failed to process backup file ${file}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-      if (deletedCount > 0) {
-        this.logger.info(`Backup cleanup: removed ${deletedCount} old backup files`);
-      }
-      return deletedCount;
-    } catch (error) {
-      this.logger.warn(
-        `Failed to cleanup backup directory: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return 0;
-    }
-  }
-  /**
-   * Get service configuration
-   */
-  getConfig() {
-    return { ...this.config };
-  }
-  /**
-   * Check if a path is allowed (async for non-blocking symlink resolution)
-   */
-  async isPathAllowed(filePath) {
-    const validation = await this.pathValidator.validatePath(filePath);
-    return validation.isValid;
-  }
-}
-export {
-  FileSystemService
-};

package/dist/filesystem/index.cjs

@@ -1,37 +0,0 @@
-"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 filesystem_exports = {};
-__export(filesystem_exports, {
-  FileSystemError: () => import_errors.FileSystemError,
-  FileSystemErrorCode: () => import_error_codes.FileSystemErrorCode,
-  FileSystemService: () => import_filesystem_service.FileSystemService,
-  PathValidator: () => import_path_validator.PathValidator
-});
-module.exports = __toCommonJS(filesystem_exports);
-var import_filesystem_service = require("./filesystem-service.js");
-var import_path_validator = require("./path-validator.js");
-var import_errors = require("./errors.js");
-var import_error_codes = require("./error-codes.js");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FileSystemError,
-  FileSystemErrorCode,
-  FileSystemService,
-  PathValidator
-});

package/dist/filesystem/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * FileSystem Module
- *
- * Exports file system service, types, errors, and utilities
- */
-export { FileSystemService } from './filesystem-service.js';
-export { PathValidator, type DirectoryApprovalChecker } from './path-validator.js';
-export { FileSystemError } from './errors.js';
-export { FileSystemErrorCode } from './error-codes.js';
-export type { FileSystemConfig, FileContent, ReadFileOptions, GlobOptions, GlobResult, GrepOptions, SearchResult, SearchMatch, WriteFileOptions, WriteResult, EditFileOptions, EditResult, EditOperation, FileMetadata, PathValidation, BufferEncoding, } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/filesystem/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/filesystem/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,YAAY,EACR,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,WAAW,EACX,UAAU,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,eAAe,EACf,UAAU,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACd,cAAc,GACjB,MAAM,YAAY,CAAC"}

package/dist/filesystem/index.js

@@ -1,11 +0,0 @@
-import "../chunk-PTJYTZNU.js";
-import { FileSystemService } from "./filesystem-service.js";
-import { PathValidator } from "./path-validator.js";
-import { FileSystemError } from "./errors.js";
-import { FileSystemErrorCode } from "./error-codes.js";
-export {
-  FileSystemError,
-  FileSystemErrorCode,
-  FileSystemService,
-  PathValidator
-};