@dexto/tools-process 1.5.8 → 1.6.1

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,10 @@ 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",
+    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,27 +95,39 @@ 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,
-    /**
-     * Generate preview for approval UI - shows the command to be executed
-     */
-    generatePreview: async (input, _context) => {
-      const { command, run_in_background } = input;
-      const preview = {
-        type: "shell",
-        command,
-        exitCode: 0,
-        // Placeholder - not executed yet
-        duration: 0,
-        // Placeholder - not executed yet
-        ...run_in_background !== void 0 && { isBackground: run_in_background }
-      };
-      return preview;
+    approval: {
+      patternKey: (input) => (0, import_command_pattern_utils.generateCommandPatternKey)(input.command),
+      suggestPatterns: (input) => (0, import_command_pattern_utils.generateCommandPatternSuggestions)(input.command)
     },
-    execute: async (input, context) => {
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Bash",
+        argsText: (0, import_core.truncateForHeader)(input.command, 140)
+      }),
+      /**
+       * Generate preview for approval UI - shows the command to be executed
+       */
+      preview: async (input, _context) => {
+        const { command, run_in_background } = input;
+        const preview = {
+          type: "shell",
+          title: "Bash",
+          command,
+          exitCode: 0,
+          // Placeholder - not executed yet
+          duration: 0,
+          // Placeholder - not executed yet
+          isBackground: run_in_background
+        };
+        return preview;
+      }
+    },
+    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,17 +139,18 @@ 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 = {
           type: "shell",
+          title: "Bash",
           command,
           exitCode: result.exitCode,
           duration: result.duration,
@@ -152,6 +168,7 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
       } else {
         const _display = {
           type: "shell",
+          title: "Bash",
           command,
           exitCode: 0,
           // Background process hasn't exited yet
@@ -166,7 +183,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.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,CAmKlC"}

package/dist/bash-exec-tool.js

@@ -1,8 +1,13 @@
 import * as path from "node:path";
 import { z } from "zod";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } 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,10 @@ 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",
+    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,27 +65,39 @@ 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,
-    /**
-     * Generate preview for approval UI - shows the command to be executed
-     */
-    generatePreview: async (input, _context) => {
-      const { command, run_in_background } = input;
-      const preview = {
-        type: "shell",
-        command,
-        exitCode: 0,
-        // Placeholder - not executed yet
-        duration: 0,
-        // Placeholder - not executed yet
-        ...run_in_background !== void 0 && { isBackground: run_in_background }
-      };
-      return preview;
+    approval: {
+      patternKey: (input) => generateCommandPatternKey(input.command),
+      suggestPatterns: (input) => generateCommandPatternSuggestions(input.command)
     },
-    execute: async (input, context) => {
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Bash",
+        argsText: truncateForHeader(input.command, 140)
+      }),
+      /**
+       * Generate preview for approval UI - shows the command to be executed
+       */
+      preview: async (input, _context) => {
+        const { command, run_in_background } = input;
+        const preview = {
+          type: "shell",
+          title: "Bash",
+          command,
+          exitCode: 0,
+          // Placeholder - not executed yet
+          duration: 0,
+          // Placeholder - not executed yet
+          isBackground: run_in_background
+        };
+        return preview;
+      }
+    },
+    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,17 +109,18 @@ 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 = {
           type: "shell",
+          title: "Bash",
           command,
           exitCode: result.exitCode,
           duration: result.duration,
@@ -119,6 +138,7 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
       } else {
         const _display = {
           type: "shell",
+          title: "Bash",
           command,
           exitCode: 0,
           // Background process hasn't exited yet
@@ -133,7 +153,7 @@ Security: Dangerous commands are blocked. Injection attempts are detected. Requi
         };
       }
     }
-  };
+  });
 }
 export {
   createBashExecTool

package/dist/bash-output-tool.cjs

@@ -22,17 +22,25 @@ __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",
     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) => {
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Bash Output",
+        argsText: (0, import_core.truncateForHeader)(input.process_id, 80)
+      })
+    },
+    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 +49,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.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,CA+BpC"}

package/dist/bash-output-tool.js

@@ -1,15 +1,23 @@
 import { z } from "zod";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } 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",
     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) => {
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Bash Output",
+        argsText: truncateForHeader(input.process_id, 80)
+      })
+    },
+    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 +26,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.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
+};

package/dist/command-pattern-utils.test.cjs

@@ -0,0 +1,80 @@
+"use strict";
+var import_command_pattern_utils = require("./command-pattern-utils.js");
+var import_vitest = require("vitest");
+(0, import_vitest.describe)("command-pattern-utils", () => {
+  (0, import_vitest.describe)("isDangerousCommand", () => {
+    (0, import_vitest.it)("should detect dangerous commands", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("rm -rf /")).toBe(true);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("sudo apt install")).toBe(true);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("chmod 777 file")).toBe(true);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("kill -9 1234")).toBe(true);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("dd if=/dev/zero of=/dev/sda")).toBe(true);
+    });
+    (0, import_vitest.it)("should not flag safe commands", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("ls -la")).toBe(false);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("git status")).toBe(false);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("npm install")).toBe(false);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("cat file.txt")).toBe(false);
+    });
+    (0, import_vitest.it)("should be case-insensitive", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("RM -rf /")).toBe(true);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("SUDO apt install")).toBe(true);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("Chmod 777 file")).toBe(true);
+    });
+    (0, import_vitest.it)("should handle empty input", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("")).toBe(false);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.isDangerousCommand)("   ")).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("generateCommandPatternKey", () => {
+    (0, import_vitest.it)("should generate patterns for simple commands", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("ls")).toBe("ls *");
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("pwd")).toBe("pwd *");
+    });
+    (0, import_vitest.it)("should ignore flags when choosing subcommand", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("ls -la")).toBe("ls *");
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("git -v status")).toBe("git status *");
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("npm --verbose install")).toBe("npm install *");
+    });
+    (0, import_vitest.it)("should generate subcommand patterns", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("git status")).toBe("git status *");
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("git push origin main")).toBe("git push *");
+    });
+    (0, import_vitest.it)("should return null for dangerous commands", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("rm -rf /")).toBeNull();
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("sudo apt install")).toBeNull();
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("shutdown -h now")).toBeNull();
+    });
+    (0, import_vitest.it)("should handle empty input", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("")).toBeNull();
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("   ")).toBeNull();
+    });
+    (0, import_vitest.it)("should trim and normalize whitespace", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("  ls   -la  ")).toBe("ls *");
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternKey)("  git   push   origin  ")).toBe("git push *");
+    });
+  });
+  (0, import_vitest.describe)("generateCommandPatternSuggestions", () => {
+    (0, import_vitest.it)("should generate broad-to-narrow suggestions", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternSuggestions)("ls")).toEqual(["ls *"]);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternSuggestions)("git push origin main")).toEqual([
+        "git push *",
+        "git *"
+      ]);
+    });
+    (0, import_vitest.it)("should return empty for dangerous commands", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternSuggestions)("rm -rf /")).toEqual([]);
+    });
+    (0, import_vitest.it)("should handle empty input", () => {
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternSuggestions)("")).toEqual([]);
+      (0, import_vitest.expect)((0, import_command_pattern_utils.generateCommandPatternSuggestions)("   ")).toEqual([]);
+    });
+    (0, import_vitest.it)("should keep suggestions consistent with pattern key", () => {
+      const command = "git push origin main";
+      const patternKey = (0, import_command_pattern_utils.generateCommandPatternKey)(command);
+      const suggestions = (0, import_command_pattern_utils.generateCommandPatternSuggestions)(command);
+      (0, import_vitest.expect)(patternKey).toBe("git push *");
+      (0, import_vitest.expect)(suggestions[0]).toBe(patternKey);
+    });
+  });
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=command-pattern-utils.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"command-pattern-utils.test.d.ts","sourceRoot":"","sources":["../src/command-pattern-utils.test.ts"],"names":[],"mappings":""}