@dexto/tools-process 1.5.7 → 1.6.0

package/dist/bash-exec-tool.cjs

@@ -33,9 +33,11 @@ __export(bash_exec_tool_exports, {
 module.exports = __toCommonJS(bash_exec_tool_exports);
 var path = __toESM(require("node:path"), 1);
 var import_zod = require("zod");
+var import_core = require("@dexto/core");
 var import_errors = require("./errors.js");
+var import_command_pattern_utils = require("./command-pattern-utils.js");
 const BashExecInputSchema = import_zod.z.object({
-  command: import_zod.z.string().describe("Shell command to execute"),
+  command: import_zod.z.string().min(1).describe("Shell command to execute"),
   description: import_zod.z.string().optional().describe("Human-readable description of what the command does (5-10 words)"),
   timeout: import_zod.z.number().int().positive().max(6e5).optional().default(12e4).describe(
     "Timeout in milliseconds (max: 600000 = 10 minutes, default: 120000 = 2 minutes)"
@@ -43,9 +45,11 @@ const BashExecInputSchema = import_zod.z.object({
   run_in_background: import_zod.z.boolean().optional().default(false).describe("Execute command in background (default: false)"),
   cwd: import_zod.z.string().optional().describe("Working directory for command execution (optional)")
 }).strict();
-function createBashExecTool(processService) {
-  return {
+function createBashExecTool(getProcessService) {
+  return (0, import_core.defineTool)({
     id: "bash_exec",
+    displayName: "Bash",
+    aliases: ["bash"],
     description: `Execute a shell command in the project root directory.
 
 IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. Do NOT use it for file operations - use the specialized tools instead:
@@ -92,10 +96,18 @@ Each command runs in a fresh shell, so cd does not persist between calls.
 
 Security: Dangerous commands are blocked. Injection attempts are detected. Requires approval with pattern-based session memory.`,
     inputSchema: BashExecInputSchema,
+    getApprovalPatternKey(input) {
+      const command = input.command;
+      return (0, import_command_pattern_utils.generateCommandPatternKey)(command);
+    },
+    suggestApprovalPatterns(input) {
+      const command = input.command;
+      return (0, import_command_pattern_utils.generateCommandPatternSuggestions)(command);
+    },
     /**
      * Generate preview for approval UI - shows the command to be executed
      */
-    generatePreview: async (input, _context) => {
+    async generatePreview(input, _context) {
       const { command, run_in_background } = input;
       const preview = {
         type: "shell",
@@ -104,15 +116,16 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
         // Placeholder - not executed yet
         duration: 0,
         // Placeholder - not executed yet
-        ...run_in_background !== void 0 && { isBackground: run_in_background }
+        isBackground: run_in_background
       };
       return preview;
     },
-    execute: async (input, context) => {
+    async execute(input, context) {
+      const resolvedProcessService = await getProcessService(context);
       const { command, description, timeout, run_in_background, cwd } = input;
       let validatedCwd = cwd;
       if (cwd) {
-        const baseDir = processService.getConfig().workingDirectory || process.cwd();
+        const baseDir = resolvedProcessService.getConfig().workingDirectory || process.cwd();
         const candidatePath = path.isAbsolute(cwd) ? path.resolve(cwd) : path.resolve(baseDir, cwd);
         const relativePath = path.relative(baseDir, candidatePath);
         const isOutsideBase = relativePath.startsWith("..") || path.isAbsolute(relativePath);
@@ -124,13 +137,13 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
         }
         validatedCwd = candidatePath;
       }
-      const result = await processService.executeCommand(command, {
+      const result = await resolvedProcessService.executeCommand(command, {
         description,
         timeout,
         runInBackground: run_in_background,
         cwd: validatedCwd,
         // Pass abort signal for cancellation support
-        abortSignal: context?.abortSignal
+        abortSignal: context.abortSignal
       });
       if ("stdout" in result) {
         const _display = {
@@ -166,7 +179,7 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
         };
       }
     }
-  };
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/bash-exec-tool.d.cts

@@ -1,4 +1,5 @@
-import { InternalTool } from '@dexto/core';
+import { z } from 'zod';
+import { ToolExecutionContext, Tool } from '@dexto/core';
 import { ProcessService } from './process-service.cjs';
 import './types.cjs';
 
@@ -6,12 +7,32 @@ import './types.cjs';
  * Bash Execute Tool
  *
  * Internal tool for executing shell commands.
- * Approval is handled at the ToolManager level with pattern-based approval.
+ * Pattern-based approval support is declared on the tool (ToolManager stays generic).
  */
 
+declare const BashExecInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    run_in_background: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    command: string;
+    timeout: number;
+    run_in_background: boolean;
+    description?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    command: string;
+    description?: string | undefined;
+    timeout?: number | undefined;
+    run_in_background?: boolean | undefined;
+    cwd?: string | undefined;
+}>;
 /**
  * Create the bash_exec internal tool
  */
-declare function createBashExecTool(processService: ProcessService): InternalTool;
+type ProcessServiceGetter = (context: ToolExecutionContext) => Promise<ProcessService>;
+declare function createBashExecTool(getProcessService: ProcessServiceGetter): Tool<typeof BashExecInputSchema>;
 
-export { createBashExecTool };
+export { type ProcessServiceGetter, createBashExecTool };

package/dist/bash-exec-tool.d.ts

@@ -1,17 +1,35 @@
-import { InternalTool } from '@dexto/core';
-import { ProcessService } from './process-service.js';
-import './types.js';
-
 /**
  * Bash Execute Tool
  *
  * Internal tool for executing shell commands.
- * Approval is handled at the ToolManager level with pattern-based approval.
+ * Pattern-based approval support is declared on the tool (ToolManager stays generic).
  */
-
+import { z } from 'zod';
+import type { Tool, ToolExecutionContext } from '@dexto/core';
+import { ProcessService } from './process-service.js';
+declare const BashExecInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    run_in_background: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    command: string;
+    timeout: number;
+    run_in_background: boolean;
+    cwd?: string | undefined;
+    description?: string | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    description?: string | undefined;
+    run_in_background?: boolean | undefined;
+}>;
 /**
  * Create the bash_exec internal tool
  */
-declare function createBashExecTool(processService: ProcessService): InternalTool;
-
-export { createBashExecTool };
+export type ProcessServiceGetter = (context: ToolExecutionContext) => Promise<ProcessService>;
+export declare function createBashExecTool(getProcessService: ProcessServiceGetter): Tool<typeof BashExecInputSchema>;
+export {};
+//# sourceMappingURL=bash-exec-tool.d.ts.map

package/dist/bash-exec-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-exec-tool.d.ts","sourceRoot":"","sources":["../src/bash-exec-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAQtD,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAwBZ,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;AAE9F,wBAAgB,kBAAkB,CAC9B,iBAAiB,EAAE,oBAAoB,GACxC,IAAI,CAAC,OAAO,mBAAmB,CAAC,CA+JlC"}

package/dist/bash-exec-tool.js

@@ -1,8 +1,13 @@
 import * as path from "node:path";
 import { z } from "zod";
+import { defineTool } from "@dexto/core";
 import { ProcessError } from "./errors.js";
+import {
+  generateCommandPatternKey,
+  generateCommandPatternSuggestions
+} from "./command-pattern-utils.js";
 const BashExecInputSchema = z.object({
-  command: z.string().describe("Shell command to execute"),
+  command: z.string().min(1).describe("Shell command to execute"),
   description: z.string().optional().describe("Human-readable description of what the command does (5-10 words)"),
   timeout: z.number().int().positive().max(6e5).optional().default(12e4).describe(
     "Timeout in milliseconds (max: 600000 = 10 minutes, default: 120000 = 2 minutes)"
@@ -10,9 +15,11 @@ const BashExecInputSchema = z.object({
   run_in_background: z.boolean().optional().default(false).describe("Execute command in background (default: false)"),
   cwd: z.string().optional().describe("Working directory for command execution (optional)")
 }).strict();
-function createBashExecTool(processService) {
-  return {
+function createBashExecTool(getProcessService) {
+  return defineTool({
     id: "bash_exec",
+    displayName: "Bash",
+    aliases: ["bash"],
     description: `Execute a shell command in the project root directory.
 
 IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. Do NOT use it for file operations - use the specialized tools instead:
@@ -59,10 +66,18 @@ Each command runs in a fresh shell, so cd does not persist between calls.
 
 Security: Dangerous commands are blocked. Injection attempts are detected. Requires approval with pattern-based session memory.`,
     inputSchema: BashExecInputSchema,
+    getApprovalPatternKey(input) {
+      const command = input.command;
+      return generateCommandPatternKey(command);
+    },
+    suggestApprovalPatterns(input) {
+      const command = input.command;
+      return generateCommandPatternSuggestions(command);
+    },
     /**
      * Generate preview for approval UI - shows the command to be executed
      */
-    generatePreview: async (input, _context) => {
+    async generatePreview(input, _context) {
       const { command, run_in_background } = input;
       const preview = {
         type: "shell",
@@ -71,15 +86,16 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
         // Placeholder - not executed yet
         duration: 0,
         // Placeholder - not executed yet
-        ...run_in_background !== void 0 && { isBackground: run_in_background }
+        isBackground: run_in_background
       };
       return preview;
     },
-    execute: async (input, context) => {
+    async execute(input, context) {
+      const resolvedProcessService = await getProcessService(context);
       const { command, description, timeout, run_in_background, cwd } = input;
       let validatedCwd = cwd;
       if (cwd) {
-        const baseDir = processService.getConfig().workingDirectory || process.cwd();
+        const baseDir = resolvedProcessService.getConfig().workingDirectory || process.cwd();
         const candidatePath = path.isAbsolute(cwd) ? path.resolve(cwd) : path.resolve(baseDir, cwd);
         const relativePath = path.relative(baseDir, candidatePath);
         const isOutsideBase = relativePath.startsWith("..") || path.isAbsolute(relativePath);
@@ -91,13 +107,13 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
         }
         validatedCwd = candidatePath;
       }
-      const result = await processService.executeCommand(command, {
+      const result = await resolvedProcessService.executeCommand(command, {
         description,
         timeout,
         runInBackground: run_in_background,
         cwd: validatedCwd,
         // Pass abort signal for cancellation support
-        abortSignal: context?.abortSignal
+        abortSignal: context.abortSignal
       });
       if ("stdout" in result) {
         const _display = {
@@ -133,7 +149,7 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
         };
       }
     }
-  };
+  });
 }
 export {
   createBashExecTool

package/dist/bash-output-tool.cjs

@@ -22,17 +22,20 @@ __export(bash_output_tool_exports, {
 });
 module.exports = __toCommonJS(bash_output_tool_exports);
 var import_zod = require("zod");
+var import_core = require("@dexto/core");
 const BashOutputInputSchema = import_zod.z.object({
   process_id: import_zod.z.string().describe("Process ID from bash_exec (when run_in_background=true)")
 }).strict();
-function createBashOutputTool(processService) {
-  return {
+function createBashOutputTool(getProcessService) {
+  return (0, import_core.defineTool)({
     id: "bash_output",
+    displayName: "Bash Output",
     description: "Retrieve output from a background process started with bash_exec. Returns stdout, stderr, status (running/completed/failed), exit code, and duration. Each call returns only new output since last read. The output buffer is cleared after reading. Use this tool to monitor long-running commands.",
     inputSchema: BashOutputInputSchema,
-    execute: async (input, _context) => {
+    async execute(input, context) {
+      const resolvedProcessService = await getProcessService(context);
       const { process_id } = input;
-      const result = await processService.getProcessOutput(process_id);
+      const result = await resolvedProcessService.getProcessOutput(process_id);
       return {
         stdout: result.stdout,
         stderr: result.stderr,
@@ -41,7 +44,7 @@ function createBashOutputTool(processService) {
         ...result.duration !== void 0 && { duration: result.duration }
       };
     }
-  };
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/bash-output-tool.d.cts

@@ -1,5 +1,7 @@
-import { InternalTool } from '@dexto/core';
-import { ProcessService } from './process-service.cjs';
+import { z } from 'zod';
+import { Tool } from '@dexto/core';
+import { ProcessServiceGetter } from './bash-exec-tool.cjs';
+import './process-service.cjs';
 import './types.cjs';
 
 /**
@@ -8,9 +10,16 @@ import './types.cjs';
  * Internal tool for retrieving output from background processes
  */
 
+declare const BashOutputInputSchema: z.ZodObject<{
+    process_id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    process_id: string;
+}, {
+    process_id: string;
+}>;
 /**
  * Create the bash_output internal tool
  */
-declare function createBashOutputTool(processService: ProcessService): InternalTool;
+declare function createBashOutputTool(getProcessService: ProcessServiceGetter): Tool<typeof BashOutputInputSchema>;
 
 export { createBashOutputTool };

package/dist/bash-output-tool.d.ts

@@ -1,16 +1,21 @@
-import { InternalTool } from '@dexto/core';
-import { ProcessService } from './process-service.js';
-import './types.js';
-
 /**
  * Bash Output Tool
  *
  * Internal tool for retrieving output from background processes
  */
-
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+import type { ProcessServiceGetter } from './bash-exec-tool.js';
+declare const BashOutputInputSchema: z.ZodObject<{
+    process_id: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    process_id: string;
+}, {
+    process_id: string;
+}>;
 /**
  * Create the bash_output internal tool
  */
-declare function createBashOutputTool(processService: ProcessService): InternalTool;
-
-export { createBashOutputTool };
+export declare function createBashOutputTool(getProcessService: ProcessServiceGetter): Tool<typeof BashOutputInputSchema>;
+export {};
+//# sourceMappingURL=bash-output-tool.d.ts.map

package/dist/bash-output-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bash-output-tool.d.ts","sourceRoot":"","sources":["../src/bash-output-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAEhE,QAAA,MAAM,qBAAqB;;;;;;EAId,CAAC;AAEd;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,iBAAiB,EAAE,oBAAoB,GACxC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAyBpC"}

package/dist/bash-output-tool.js

@@ -1,15 +1,18 @@
 import { z } from "zod";
+import { defineTool } from "@dexto/core";
 const BashOutputInputSchema = z.object({
   process_id: z.string().describe("Process ID from bash_exec (when run_in_background=true)")
 }).strict();
-function createBashOutputTool(processService) {
-  return {
+function createBashOutputTool(getProcessService) {
+  return defineTool({
     id: "bash_output",
+    displayName: "Bash Output",
     description: "Retrieve output from a background process started with bash_exec. Returns stdout, stderr, status (running/completed/failed), exit code, and duration. Each call returns only new output since last read. The output buffer is cleared after reading. Use this tool to monitor long-running commands.",
     inputSchema: BashOutputInputSchema,
-    execute: async (input, _context) => {
+    async execute(input, context) {
+      const resolvedProcessService = await getProcessService(context);
       const { process_id } = input;
-      const result = await processService.getProcessOutput(process_id);
+      const result = await resolvedProcessService.getProcessOutput(process_id);
       return {
         stdout: result.stdout,
         stderr: result.stderr,
@@ -18,7 +21,7 @@ function createBashOutputTool(processService) {
         ...result.duration !== void 0 && { duration: result.duration }
       };
     }
-  };
+  });
 }
 export {
   createBashOutputTool

package/dist/command-pattern-utils.cjs

@@ -0,0 +1,83 @@
+"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 command_pattern_utils_exports = {};
+__export(command_pattern_utils_exports, {
+  DANGEROUS_COMMAND_PREFIXES: () => DANGEROUS_COMMAND_PREFIXES,
+  generateCommandPatternKey: () => generateCommandPatternKey,
+  generateCommandPatternSuggestions: () => generateCommandPatternSuggestions,
+  isDangerousCommand: () => isDangerousCommand
+});
+module.exports = __toCommonJS(command_pattern_utils_exports);
+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[0]) return false;
+  const head = tokens[0].toLowerCase();
+  return DANGEROUS_COMMAND_PREFIXES.includes(head);
+}
+function generateCommandPatternKey(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (!tokens[0]) return null;
+  const head = tokens[0].toLowerCase();
+  if (isDangerousCommand(command)) {
+    return null;
+  }
+  const subcommand = tokens.slice(1).find((arg) => !arg.startsWith("-"));
+  return subcommand ? `${head} ${subcommand.toLowerCase()} *` : `${head} *`;
+}
+function generateCommandPatternSuggestions(command) {
+  const tokens = command.trim().toLowerCase().split(/\s+/);
+  if (!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,
+  generateCommandPatternKey,
+  generateCommandPatternSuggestions,
+  isDangerousCommand
+});

package/dist/command-pattern-utils.d.cts

@@ -0,0 +1,30 @@
+/**
+ * Utility functions for generating approval patterns for shell commands.
+ *
+ * Pattern-based approvals allow users to approve command patterns like "git *"
+ * that automatically cover future matching commands (e.g., "git status", "git push").
+ */
+/**
+ * Commands that should never get auto-approve pattern suggestions.
+ * These require explicit approval each time for safety.
+ */
+declare const DANGEROUS_COMMAND_PREFIXES: readonly ["rm", "chmod", "chown", "chgrp", "sudo", "su", "dd", "mkfs", "fdisk", "parted", "kill", "killall", "pkill", "shutdown", "reboot", "halt", "poweroff"];
+declare function isDangerousCommand(command: string): boolean;
+/**
+ * Generate the pattern key for a shell command.
+ *
+ * Examples:
+ * - "ls -la" → "ls *" (flags don't count as subcommand)
+ * - "git push origin" → "git push *" (first non-flag arg is subcommand)
+ * - "rm -rf /" → null (dangerous command)
+ */
+declare function generateCommandPatternKey(command: string): string | null;
+/**
+ * Generate suggested patterns for UI selection.
+ * Returns progressively broader patterns from specific to general.
+ *
+ * Example: "git push origin main" → ["git push *", "git *"]
+ */
+declare function generateCommandPatternSuggestions(command: string): string[];
+
+export { DANGEROUS_COMMAND_PREFIXES, generateCommandPatternKey, generateCommandPatternSuggestions, isDangerousCommand };

package/dist/command-pattern-utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Utility functions for generating approval patterns for shell commands.
+ *
+ * Pattern-based approvals allow users to approve command patterns like "git *"
+ * that automatically cover future matching commands (e.g., "git status", "git push").
+ */
+/**
+ * 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"];
+export declare function isDangerousCommand(command: string): boolean;
+/**
+ * Generate the pattern key for a shell command.
+ *
+ * Examples:
+ * - "ls -la" → "ls *" (flags don't count as subcommand)
+ * - "git push origin" → "git push *" (first non-flag arg is subcommand)
+ * - "rm -rf /" → null (dangerous command)
+ */
+export declare function generateCommandPatternKey(command: string): string | null;
+/**
+ * Generate suggested patterns for UI selection.
+ * Returns progressively broader patterns from specific to general.
+ *
+ * Example: "git push origin main" → ["git push *", "git *"]
+ */
+export declare function generateCommandPatternSuggestions(command: string): string[];
+//# sourceMappingURL=command-pattern-utils.d.ts.map

package/dist/command-pattern-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-pattern-utils.d.ts","sourceRoot":"","sources":["../src/command-pattern-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,0BAA0B,iKAkB7B,CAAC;AAEX,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAK3D;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYxE;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB3E"}

package/dist/command-pattern-utils.js

@@ -0,0 +1,56 @@
+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[0]) return false;
+  const head = tokens[0].toLowerCase();
+  return DANGEROUS_COMMAND_PREFIXES.includes(head);
+}
+function generateCommandPatternKey(command) {
+  const tokens = command.trim().split(/\s+/);
+  if (!tokens[0]) return null;
+  const head = tokens[0].toLowerCase();
+  if (isDangerousCommand(command)) {
+    return null;
+  }
+  const subcommand = tokens.slice(1).find((arg) => !arg.startsWith("-"));
+  return subcommand ? `${head} ${subcommand.toLowerCase()} *` : `${head} *`;
+}
+function generateCommandPatternSuggestions(command) {
+  const tokens = command.trim().toLowerCase().split(/\s+/);
+  if (!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,
+  generateCommandPatternKey,
+  generateCommandPatternSuggestions,
+  isDangerousCommand
+};