@dexto/core 1.5.7 → 1.6.0

package/dist/storage/schemas.d.ts

@@ -1,347 +0,0 @@
-import { z } from 'zod';
-export { CACHE_TYPES, CacheConfigSchema, type CacheType, type CacheConfig, type InMemoryCacheConfig, type RedisCacheConfig, } from './cache/schemas.js';
-export { DATABASE_TYPES, DatabaseConfigSchema, type DatabaseType, type DatabaseConfig, type InMemoryDatabaseConfig, type SqliteDatabaseConfig, type PostgresDatabaseConfig, } from './database/schemas.js';
-export { BLOB_STORE_TYPES, BlobStoreConfigSchema, InMemoryBlobStoreSchema, LocalBlobStoreSchema, type BlobStoreType, type BlobStoreConfig, type InMemoryBlobStoreConfig, type LocalBlobStoreConfig, } from './blob/schemas.js';
-/**
- * Top-level storage configuration schema
- * Composes cache, database, and blob store configurations
- *
- * Note: Blob config uses runtime validation via the provider registry,
- * allowing custom providers to be registered at the CLI/server layer.
- */
-export declare const StorageSchema: z.ZodBranded<z.ZodObject<{
-    cache: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-        maxConnections: z.ZodOptional<z.ZodNumber>;
-        idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    } & {
-        type: z.ZodLiteral<"in-memory">;
-    }, "strict", z.ZodTypeAny, {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    }, {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    }>, z.ZodObject<{
-        maxConnections: z.ZodOptional<z.ZodNumber>;
-        idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    } & {
-        type: z.ZodLiteral<"redis">;
-        url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-        host: z.ZodOptional<z.ZodString>;
-        port: z.ZodOptional<z.ZodNumber>;
-        password: z.ZodOptional<z.ZodString>;
-        database: z.ZodOptional<z.ZodNumber>;
-    }, "strict", z.ZodTypeAny, {
-        type: "redis";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: number | undefined;
-    }, {
-        type: "redis";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: number | undefined;
-    }>]>, {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        type: "redis";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: number | undefined;
-    }, {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        type: "redis";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: number | undefined;
-    }>;
-    database: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-        maxConnections: z.ZodOptional<z.ZodNumber>;
-        idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    } & {
-        type: z.ZodLiteral<"in-memory">;
-    }, "strict", z.ZodTypeAny, {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    }, {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    }>, z.ZodObject<{
-        maxConnections: z.ZodOptional<z.ZodNumber>;
-        idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    } & {
-        type: z.ZodLiteral<"sqlite">;
-        path: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        path: string;
-        type: "sqlite";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    }, {
-        path: string;
-        type: "sqlite";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    }>, z.ZodObject<{
-        maxConnections: z.ZodOptional<z.ZodNumber>;
-        idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
-        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    } & {
-        type: z.ZodLiteral<"postgres">;
-        url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-        connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-        host: z.ZodOptional<z.ZodString>;
-        port: z.ZodOptional<z.ZodNumber>;
-        database: z.ZodOptional<z.ZodString>;
-        password: z.ZodOptional<z.ZodString>;
-        keyPrefix: z.ZodOptional<z.ZodString>;
-    }, "strict", z.ZodTypeAny, {
-        type: "postgres";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: string | undefined;
-        connectionString?: string | undefined;
-        keyPrefix?: string | undefined;
-    }, {
-        type: "postgres";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: string | undefined;
-        connectionString?: string | undefined;
-        keyPrefix?: string | undefined;
-    }>]>, {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        path: string;
-        type: "sqlite";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        type: "postgres";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: string | undefined;
-        connectionString?: string | undefined;
-        keyPrefix?: string | undefined;
-    }, {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        path: string;
-        type: "sqlite";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        type: "postgres";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: string | undefined;
-        connectionString?: string | undefined;
-        keyPrefix?: string | undefined;
-    }>;
-    blob: z.ZodObject<{
-        type: z.ZodString;
-    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-        type: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-        type: z.ZodString;
-    }, z.ZodTypeAny, "passthrough">>;
-}, "strict", z.ZodTypeAny, {
-    database: {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        path: string;
-        type: "sqlite";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        type: "postgres";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: string | undefined;
-        connectionString?: string | undefined;
-        keyPrefix?: string | undefined;
-    };
-    cache: {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        type: "redis";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: number | undefined;
-    };
-    blob: {
-        type: string;
-    } & {
-        [k: string]: unknown;
-    };
-}, {
-    database: {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        path: string;
-        type: "sqlite";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        type: "postgres";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: string | undefined;
-        connectionString?: string | undefined;
-        keyPrefix?: string | undefined;
-    };
-    cache: {
-        type: "in-memory";
-        options?: Record<string, any> | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-    } | {
-        type: "redis";
-        password?: string | undefined;
-        options?: Record<string, any> | undefined;
-        url?: string | undefined;
-        maxConnections?: number | undefined;
-        idleTimeoutMillis?: number | undefined;
-        connectionTimeoutMillis?: number | undefined;
-        host?: string | undefined;
-        port?: number | undefined;
-        database?: number | undefined;
-    };
-    blob: {
-        type: string;
-    } & {
-        [k: string]: unknown;
-    };
-}>, "ValidatedStorageConfig">;
-export type StorageConfig = z.input<typeof StorageSchema>;
-export type ValidatedStorageConfig = z.output<typeof StorageSchema>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/storage/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/storage/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC9B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC5B,MAAM,mBAAmB,CAAC;AAO3B;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAUY,CAAC;AAEvC,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC1D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/storage/schemas.js

@@ -1,37 +0,0 @@
-import "../chunk-PTJYTZNU.js";
-import { z } from "zod";
-import {
-  CACHE_TYPES,
-  CacheConfigSchema
-} from "./cache/schemas.js";
-import {
-  DATABASE_TYPES,
-  DatabaseConfigSchema
-} from "./database/schemas.js";
-import {
-  BLOB_STORE_TYPES,
-  BlobStoreConfigSchema,
-  InMemoryBlobStoreSchema,
-  LocalBlobStoreSchema
-} from "./blob/schemas.js";
-import { CacheConfigSchema as CacheConfigSchema2 } from "./cache/schemas.js";
-import { DatabaseConfigSchema as DatabaseConfigSchema2 } from "./database/schemas.js";
-import { BlobStoreConfigSchema as BlobStoreConfigSchema2 } from "./blob/schemas.js";
-const StorageSchema = z.object({
-  cache: CacheConfigSchema2.describe("Cache configuration (fast, ephemeral)"),
-  database: DatabaseConfigSchema2.describe("Database configuration (persistent, reliable)"),
-  blob: BlobStoreConfigSchema2.describe(
-    "Blob store configuration (for large, unstructured data)"
-  )
-}).strict().describe("Storage configuration with cache, database, and blob store").brand();
-export {
-  BLOB_STORE_TYPES,
-  BlobStoreConfigSchema,
-  CACHE_TYPES,
-  CacheConfigSchema,
-  DATABASE_TYPES,
-  DatabaseConfigSchema,
-  InMemoryBlobStoreSchema,
-  LocalBlobStoreSchema,
-  StorageSchema
-};

package/dist/tools/bash-pattern-utils.cjs

@@ -1,91 +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 bash_pattern_utils_exports = {};
-__export(bash_pattern_utils_exports, {
-  DANGEROUS_COMMAND_PREFIXES: () => DANGEROUS_COMMAND_PREFIXES,
-  generateBashPatternKey: () => generateBashPatternKey,
-  generateBashPatternSuggestions: () => generateBashPatternSuggestions,
-  isDangerousCommand: () => isDangerousCommand,
-  patternCovers: () => patternCovers
-});
-module.exports = __toCommonJS(bash_pattern_utils_exports);
-function patternCovers(storedPattern, targetPatternKey) {
-  if (storedPattern === targetPatternKey) return true;
-  const storedBase = storedPattern.endsWith(" *") ? storedPattern.slice(0, -2) : storedPattern;
-  const targetBase = targetPatternKey.endsWith(" *") ? targetPatternKey.slice(0, -2) : targetPatternKey;
-  return targetBase.startsWith(storedBase + " ");
-}
-const DANGEROUS_COMMAND_PREFIXES = [
-  "rm",
-  "chmod",
-  "chown",
-  "chgrp",
-  "sudo",
-  "su",
-  "dd",
-  "mkfs",
-  "fdisk",
-  "parted",
-  "kill",
-  "killall",
-  "pkill",
-  "shutdown",
-  "reboot",
-  "halt",
-  "poweroff"
-];
-function isDangerousCommand(command) {
-  const tokens = command.trim().split(/\s+/);
-  if (tokens.length === 0 || !tokens[0]) return false;
-  const head = tokens[0].toLowerCase();
-  return DANGEROUS_COMMAND_PREFIXES.includes(head);
-}
-function generateBashPatternKey(command) {
-  const tokens = command.trim().split(/\s+/);
-  if (tokens.length === 0 || !tokens[0]) return null;
-  const head = tokens[0];
-  if (isDangerousCommand(command)) {
-    return null;
-  }
-  const subcommand = tokens.slice(1).find((arg) => !arg.startsWith("-"));
-  return subcommand ? `${head} ${subcommand} *` : `${head} *`;
-}
-function generateBashPatternSuggestions(command) {
-  const tokens = command.trim().split(/\s+/);
-  if (tokens.length === 0 || !tokens[0]) return [];
-  const head = tokens[0];
-  if (isDangerousCommand(command)) {
-    return [];
-  }
-  const patterns = [];
-  const nonFlagArgs = tokens.slice(1).filter((arg) => !arg.startsWith("-"));
-  if (nonFlagArgs.length > 0) {
-    patterns.push(`${head} ${nonFlagArgs[0]} *`);
-  }
-  patterns.push(`${head} *`);
-  return patterns;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DANGEROUS_COMMAND_PREFIXES,
-  generateBashPatternKey,
-  generateBashPatternSuggestions,
-  isDangerousCommand,
-  patternCovers
-});

package/dist/tools/bash-pattern-utils.d.ts

@@ -1,58 +0,0 @@
-/**
- * Utility functions for bash command pattern generation and matching.
- *
- * Pattern-based approval allows users to approve command patterns like "git *"
- * that automatically cover future matching commands (e.g., "git status", "git push").
- */
-/**
- * Check if a stored pattern covers a target pattern key.
- * Pattern A covers pattern B if:
- * 1. A == B (exact match), OR
- * 2. B's base starts with A's base + " " (broader pattern covers narrower)
- *
- * Examples:
- * - `git *` covers `git push *`: base `git` is prefix of base `git push`
- * - `ls *` covers `ls *`: exact match
- * - `npm *` does NOT cover `npx *`: `npx` doesn't start with `npm `
- *
- * @param storedPattern The approved pattern (e.g., "git *")
- * @param targetPatternKey The pattern key to check (e.g., "git push *")
- * @returns true if storedPattern covers targetPatternKey
- */
-export declare function patternCovers(storedPattern: string, targetPatternKey: string): boolean;
-/**
- * Commands that should never get auto-approve pattern suggestions.
- * These require explicit approval each time for safety.
- */
-export declare const DANGEROUS_COMMAND_PREFIXES: readonly ["rm", "chmod", "chown", "chgrp", "sudo", "su", "dd", "mkfs", "fdisk", "parted", "kill", "killall", "pkill", "shutdown", "reboot", "halt", "poweroff"];
-/**
- * Check if a command prefix is dangerous (should not get pattern suggestions).
- */
-export declare function isDangerousCommand(command: string): boolean;
-/**
- * Generate the pattern key for a bash command.
- * This is what gets stored when user approves, and what gets checked against approved patterns.
- *
- * Examples:
- * - "ls -la" → "ls *" (flags don't count as subcommand)
- * - "git push origin" → "git push *" (first non-flag arg is subcommand)
- * - "git status" → "git status *"
- * - "rm -rf /" → null (dangerous command)
- *
- * @param command The bash command to generate a pattern key for
- * @returns The pattern key, or null if the command is dangerous
- */
-export declare function generateBashPatternKey(command: string): string | null;
-/**
- * Generate suggested patterns for UI selection.
- * Returns progressively broader patterns from specific to general.
- *
- * Example: "git push origin main" generates:
- *   - "git push *" (the pattern key)
- *   - "git *" (broader)
- *
- * @param command The bash command to generate suggestions for
- * @returns Array of pattern suggestions (empty for dangerous commands)
- */
-export declare function generateBashPatternSuggestions(command: string): string[];
-//# sourceMappingURL=bash-pattern-utils.d.ts.map

package/dist/tools/bash-pattern-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bash-pattern-utils.d.ts","sourceRoot":"","sources":["../../src/tools/bash-pattern-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAatF;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,iKAkB7B,CAAC;AAEX;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAK3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAerE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAuBxE"}

package/dist/tools/bash-pattern-utils.js

@@ -1,64 +0,0 @@
-import "../chunk-PTJYTZNU.js";
-function patternCovers(storedPattern, targetPatternKey) {
-  if (storedPattern === targetPatternKey) return true;
-  const storedBase = storedPattern.endsWith(" *") ? storedPattern.slice(0, -2) : storedPattern;
-  const targetBase = targetPatternKey.endsWith(" *") ? targetPatternKey.slice(0, -2) : targetPatternKey;
-  return targetBase.startsWith(storedBase + " ");
-}
-const DANGEROUS_COMMAND_PREFIXES = [
-  "rm",
-  "chmod",
-  "chown",
-  "chgrp",
-  "sudo",
-  "su",
-  "dd",
-  "mkfs",
-  "fdisk",
-  "parted",
-  "kill",
-  "killall",
-  "pkill",
-  "shutdown",
-  "reboot",
-  "halt",
-  "poweroff"
-];
-function isDangerousCommand(command) {
-  const tokens = command.trim().split(/\s+/);
-  if (tokens.length === 0 || !tokens[0]) return false;
-  const head = tokens[0].toLowerCase();
-  return DANGEROUS_COMMAND_PREFIXES.includes(head);
-}
-function generateBashPatternKey(command) {
-  const tokens = command.trim().split(/\s+/);
-  if (tokens.length === 0 || !tokens[0]) return null;
-  const head = tokens[0];
-  if (isDangerousCommand(command)) {
-    return null;
-  }
-  const subcommand = tokens.slice(1).find((arg) => !arg.startsWith("-"));
-  return subcommand ? `${head} ${subcommand} *` : `${head} *`;
-}
-function generateBashPatternSuggestions(command) {
-  const tokens = command.trim().split(/\s+/);
-  if (tokens.length === 0 || !tokens[0]) return [];
-  const head = tokens[0];
-  if (isDangerousCommand(command)) {
-    return [];
-  }
-  const patterns = [];
-  const nonFlagArgs = tokens.slice(1).filter((arg) => !arg.startsWith("-"));
-  if (nonFlagArgs.length > 0) {
-    patterns.push(`${head} ${nonFlagArgs[0]} *`);
-  }
-  patterns.push(`${head} *`);
-  return patterns;
-}
-export {
-  DANGEROUS_COMMAND_PREFIXES,
-  generateBashPatternKey,
-  generateBashPatternSuggestions,
-  isDangerousCommand,
-  patternCovers
-};

package/dist/tools/custom-tool-registry.cjs

@@ -1,64 +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 custom_tool_registry_exports = {};
-__export(custom_tool_registry_exports, {
-  CustomToolRegistry: () => CustomToolRegistry,
-  customToolRegistry: () => customToolRegistry
-});
-module.exports = __toCommonJS(custom_tool_registry_exports);
-var import_errors = require("./errors.js");
-var import_base_registry = require("../providers/base-registry.js");
-var import_custom_tool_schema_registry = require("./custom-tool-schema-registry.js");
-const customToolErrorFactory = {
-  alreadyRegistered: (type) => import_errors.ToolError.customToolProviderAlreadyRegistered(type),
-  notFound: (type, availableTypes) => import_errors.ToolError.unknownCustomToolProvider(type, availableTypes)
-};
-class CustomToolRegistry extends import_base_registry.BaseRegistry {
-  constructor() {
-    super(customToolErrorFactory);
-  }
-  /**
-   * Register a custom tool provider.
-   * Also registers the provider's config schema for early validation.
-   *
-   * @param provider - The custom tool provider to register
-   * @throws Error if a provider with the same type is already registered
-   */
-  register(provider) {
-    super.register(provider);
-    import_custom_tool_schema_registry.customToolSchemaRegistry.register(provider.type, provider.configSchema);
-  }
-  /**
-   * Unregister a custom tool provider.
-   * Note: This does NOT unregister the schema from customToolSchemaRegistry
-   * to avoid breaking active configs that reference the schema.
-   *
-   * @param type - The provider type to unregister
-   * @returns true if the provider was unregistered, false if it wasn't registered
-   */
-  unregister(type) {
-    return super.unregister(type);
-  }
-}
-const customToolRegistry = new CustomToolRegistry();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CustomToolRegistry,
-  customToolRegistry
-});