@kkeve/suite 0.0.1

package/dist/skill/frontmatter-parser.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * SKILL.md Frontmatter Parser
+ *
+ * Reference: gemini-cli skillLoader.ts (skills/skillLoader.ts L34-110)
+ * Parses YAML frontmatter from SKILL.md files to extract name, description,
+ * and allowed-tools. Uses the 'yaml' npm package for robust YAML parsing,
+ * with a fallback simple parser for malformed YAML (e.g. descriptions with colons).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRONTMATTER_REGEX = void 0;
+exports.parseSkillFrontmatter = parseSkillFrontmatter;
+exports.parseFrontmatterYaml = parseFrontmatterYaml;
+const yaml_1 = __importDefault(require("yaml"));
+/**
+ * Regex for extracting frontmatter from markdown files.
+ * Matches ---\n<yaml content>\n--- at the start of the file.
+ */
+exports.FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?/;
+/**
+ * Parse frontmatter from a SKILL.md file string.
+ *
+ * Returns the name, description, allowedTools from the YAML frontmatter,
+ * and the body (content after the frontmatter).
+ *
+ * @param content The full SKILL.md file content
+ * @returns Parsed frontmatter and body, or null if no valid frontmatter found
+ */
+function parseSkillFrontmatter(content) {
+    const match = content.match(exports.FRONTMATTER_REGEX);
+    if (!match) {
+        return null;
+    }
+    const frontmatter = parseFrontmatterYaml(match[1]);
+    if (!frontmatter) {
+        return null;
+    }
+    // Sanitize name for use as a filename/directory name
+    const sanitizedName = frontmatter.name.replace(/[:\\/<>*?"|]/g, '-');
+    // Body is the content after the closing ---
+    const body = match[2]?.trim() ?? '';
+    return {
+        name: sanitizedName,
+        description: frontmatter.description,
+        allowedTools: frontmatter.allowedTools,
+        outputType: frontmatter.outputType,
+        body,
+    };
+}
+/**
+ * Parse YAML frontmatter content using the yaml library
+ * with a fallback to simple key-value parsing.
+ *
+ * Reference: gemini-cli skillLoader.ts parseFrontmatter (L41-61)
+ *
+ * Uses YAML.parse() (yaml v2 API) instead of the deprecated YAML.load().
+ */
+function parseFrontmatterYaml(yamlContent) {
+    // Try YAML parsing first (handles complex cases like multi-line descriptions, arrays)
+    try {
+        const parsed = yaml_1.default.parse(yamlContent);
+        if (parsed && typeof parsed === 'object') {
+            const record = parsed;
+            const name = typeof record.name === 'string' ? record.name : undefined;
+            const description = typeof record.description === 'string' ? record.description : undefined;
+            if (!name || !description) {
+                return null;
+            }
+            // Extract allowed-tools (array or string)
+            let allowedTools;
+            const allowedToolsRaw = record['allowed-tools'];
+            if (Array.isArray(allowedToolsRaw)) {
+                allowedTools = allowedToolsRaw.map(String);
+            }
+            else if (typeof allowedToolsRaw === 'string') {
+                allowedTools = allowedToolsRaw.split(/\s+/).filter(Boolean);
+            }
+            // Extract output-type (string)
+            const outputType = typeof record['output-type'] === 'string' ? record['output-type'] : undefined;
+            return { name, description, allowedTools, outputType };
+        }
+    }
+    catch (yamlError) {
+        // YAML parsing failed — fall back to simple parser
+        console.warn('[SkillLoader] YAML frontmatter parsing failed, using simple parser:', yamlError);
+    }
+    return parseSimpleFrontmatter(yamlContent);
+}
+/**
+ * Simple frontmatter parser that extracts name, description, and allowed-tools fields.
+ * Handles cases where values contain colons that would break YAML parsing.
+ *
+ * Reference: gemini-cli skillLoader.ts parseSimpleFrontmatter (L67-110)
+ */
+function parseSimpleFrontmatter(content) {
+    const lines = content.split(/\r?\n/);
+    let name;
+    let description;
+    let allowedTools;
+    let outputType;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Match "name:" at the start of the line
+        const nameMatch = line.match(/^\s*name:\s*(.*)$/);
+        if (nameMatch) {
+            name = nameMatch[1].trim();
+            continue;
+        }
+        // Match "description:" at the start of the line
+        const descMatch = line.match(/^\s*description:\s*(.*)$/);
+        if (descMatch) {
+            const descLines = [descMatch[1].trim()];
+            // Check for multi-line description (indented continuation lines)
+            while (i + 1 < lines.length) {
+                const nextLine = lines[i + 1];
+                // If next line is indented, it's a continuation of the description
+                if (nextLine.match(/^[ \t]+\S/)) {
+                    descLines.push(nextLine.trim());
+                    i++;
+                }
+                else {
+                    break;
+                }
+            }
+            description = descLines.filter(Boolean).join(' ');
+            continue;
+        }
+        // Match "output-type:" at the start of the line
+        const outputMatch = line.match(/^\s*output-type:\s*(.*)$/);
+        if (outputMatch) {
+            outputType = outputMatch[1].trim();
+            continue;
+        }
+        // Match "allowed-tools:" at the start of the line
+        const toolsMatch = line.match(/^\s*allowed-tools:\s*(.*)$/);
+        if (toolsMatch) {
+            const toolsRaw = toolsMatch[1].trim();
+            // Simple format: space-separated list (e.g. "Bash(shell:*) Bash(git:*) ask_user_questions")
+            if (toolsRaw) {
+                allowedTools = toolsRaw.split(/\s+/).filter(Boolean);
+            }
+            continue;
+        }
+    }
+    if (name !== undefined && description !== undefined) {
+        return { name, description, allowedTools, outputType };
+    }
+    return null;
+}

package/dist/skill/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Skill module — SKILL.md discovery, loading, and execution
+ *
+ * Provides the SkillLoader for discovering SKILL.md files with
+ * Progressive Disclosure (frontmatter scan → full content → references),
+ * and the SkillExecutor for running skills through the AgentLoop.
+ *
+ * Reference: gemini-cli skillLoader.ts + skill-extraction-agent.ts
+ */
+export { SkillLoader } from './loader';
+export type { SkillDefinition } from './loader';
+export { parseSkillFrontmatter, FRONTMATTER_REGEX } from './frontmatter-parser';

package/dist/skill/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Skill module — SKILL.md discovery, loading, and execution
+ *
+ * Provides the SkillLoader for discovering SKILL.md files with
+ * Progressive Disclosure (frontmatter scan → full content → references),
+ * and the SkillExecutor for running skills through the AgentLoop.
+ *
+ * Reference: gemini-cli skillLoader.ts + skill-extraction-agent.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRONTMATTER_REGEX = exports.parseSkillFrontmatter = exports.SkillLoader = void 0;
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "SkillLoader", { enumerable: true, get: function () { return loader_1.SkillLoader; } });
+var frontmatter_parser_1 = require("./frontmatter-parser");
+Object.defineProperty(exports, "parseSkillFrontmatter", { enumerable: true, get: function () { return frontmatter_parser_1.parseSkillFrontmatter; } });
+Object.defineProperty(exports, "FRONTMATTER_REGEX", { enumerable: true, get: function () { return frontmatter_parser_1.FRONTMATTER_REGEX; } });

package/dist/skill/loader.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Skill Loader — discovers and loads SKILL.md files
+ *
+ * Reference: gemini-cli skillLoader.ts (skills/skillLoader.ts)
+ *
+ * Progressive Disclosure three levels:
+ * 1. scanSkillDirs() → scan all SKILL.md frontmatter (name + description only)
+ * 2. loadSkillContent() → load the full SKILL.md body for a matched skill
+ * 3. loadSkillReference() → load a specific reference file from the skill's references/ dir
+ *
+ * Skill directory scan priority:
+ * - packages/agent/skills/x/SKILL.md — project built-in skills (canonical location)
+ * - Future: user-defined skill directories (from config)
+ */
+/**
+ * A loaded skill definition.
+ * Reference: gemini-cli SkillDefinition (skills/skillLoader.ts L17-32)
+ */
+export interface SkillDefinition {
+    /** The unique name of the skill (sanitized from frontmatter). */
+    name: string;
+    /** A concise description of what the skill does. */
+    description: string;
+    /** The absolute path to the skill's SKILL.md file on disk. */
+    location: string;
+    /** The core logic/instructions of the skill (SKILL.md body). */
+    body: string;
+    /** Whether the skill is currently disabled. */
+    disabled?: boolean;
+    /** Whether the skill is a built-in skill. */
+    isBuiltin?: boolean;
+    /** Allowed tools for this skill (from frontmatter). */
+    allowedTools?: string[];
+    /** Output artifact type for Pipeline routing (e.g. 'code_knowledge', 'case_list'). */
+    outputType?: string;
+}
+/**
+ * Skill loader for discovering and loading SKILL.md files.
+ *
+ * Usage:
+ * ```typescript
+ * const loader = new SkillLoader(['packages/agent/demo/skills'])
+ * const skills = await loader.scanSkillDirs()
+ * // Find matching skill
+ * const matched = loader.matchSkill('test case generation', skills)
+ * // Load full content
+ * const content = await loader.loadSkillContent(matched.name)
+ * ```
+ */
+export declare class SkillLoader {
+    private skillDirs;
+    private skillCache;
+    constructor(skillDirs: string[]);
+    /**
+     * Level 1: Scan skill directories and load all SKILL.md frontmatter.
+     * Returns SkillDefinition objects with name, description, location, and body.
+     *
+     * Reference: gemini-cli loadSkillsFromDir (skills/skillLoader.ts L115-159)
+     */
+    scanSkillDirs(): Promise<SkillDefinition[]>;
+    /**
+     * Level 2: Load the full SKILL.md body content for a specific skill.
+     * If the skill was already scanned, returns the cached body.
+     * Otherwise, loads it from disk.
+     */
+    loadSkillContent(skillName: string): Promise<string | null>;
+    /**
+     * Level 3: Load a reference file from a skill's directory.
+     * Reference files are typically in a references/ subdirectory next to SKILL.md.
+     */
+    loadSkillReference(skillName: string, referencePath: string): Promise<string | null>;
+    /**
+     * Match a skill by query string against available skills' names and descriptions.
+     * Uses simple keyword matching — finds the skill whose name or description
+     * best matches the query.
+     */
+    matchSkill(query: string, availableSkills: SkillDefinition[]): SkillDefinition | null;
+    /**
+     * Get a cached skill definition by name.
+     */
+    getCachedSkill(skillName: string): SkillDefinition | undefined;
+    /**
+     * Get all cached skill definitions.
+     */
+    getAllCachedSkills(): SkillDefinition[];
+    /**
+     * Load all skills from a directory.
+     * Reference: gemini-cli loadSkillsFromDir (skills/skillLoader.ts L115-159)
+     */
+    private loadSkillsFromDir;
+    /**
+     * Load a single skill from a SKILL.md file.
+     * Reference: gemini-cli loadSkillFromFile (skills/skillLoader.ts L164-192)
+     */
+    private loadSkillFromFile;
+}

package/dist/skill/loader.js

@@ -0,0 +1,256 @@
+"use strict";
+/**
+ * Skill Loader — discovers and loads SKILL.md files
+ *
+ * Reference: gemini-cli skillLoader.ts (skills/skillLoader.ts)
+ *
+ * Progressive Disclosure three levels:
+ * 1. scanSkillDirs() → scan all SKILL.md frontmatter (name + description only)
+ * 2. loadSkillContent() → load the full SKILL.md body for a matched skill
+ * 3. loadSkillReference() → load a specific reference file from the skill's references/ dir
+ *
+ * Skill directory scan priority:
+ * - packages/agent/skills/x/SKILL.md — project built-in skills (canonical location)
+ * - Future: user-defined skill directories (from config)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkillLoader = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const glob_1 = require("glob");
+const frontmatter_parser_1 = require("./frontmatter-parser");
+/**
+ * Skill loader for discovering and loading SKILL.md files.
+ *
+ * Usage:
+ * ```typescript
+ * const loader = new SkillLoader(['packages/agent/demo/skills'])
+ * const skills = await loader.scanSkillDirs()
+ * // Find matching skill
+ * const matched = loader.matchSkill('test case generation', skills)
+ * // Load full content
+ * const content = await loader.loadSkillContent(matched.name)
+ * ```
+ */
+class SkillLoader {
+    skillDirs;
+    skillCache = new Map();
+    constructor(skillDirs) {
+        this.skillDirs = skillDirs;
+    }
+    /**
+     * Level 1: Scan skill directories and load all SKILL.md frontmatter.
+     * Returns SkillDefinition objects with name, description, location, and body.
+     *
+     * Reference: gemini-cli loadSkillsFromDir (skills/skillLoader.ts L115-159)
+     */
+    async scanSkillDirs() {
+        const discoveredSkills = [];
+        for (const dir of this.skillDirs) {
+            const skillsFromDir = await this.loadSkillsFromDir(dir);
+            for (const skill of skillsFromDir) {
+                this.skillCache.set(skill.name, skill);
+                discoveredSkills.push(skill);
+            }
+        }
+        return discoveredSkills;
+    }
+    /**
+     * Level 2: Load the full SKILL.md body content for a specific skill.
+     * If the skill was already scanned, returns the cached body.
+     * Otherwise, loads it from disk.
+     */
+    async loadSkillContent(skillName) {
+        const cached = this.skillCache.get(skillName);
+        if (cached) {
+            return cached.body;
+        }
+        // Try to find and load the skill file
+        for (const dir of this.skillDirs) {
+            const absoluteSearchPath = path.resolve(dir);
+            try {
+                const pattern = ['SKILL.md', '*/SKILL.md'];
+                const skillFiles = await (0, glob_1.glob)(pattern, {
+                    cwd: absoluteSearchPath,
+                    absolute: true,
+                    nodir: true,
+                    ignore: ['**/node_modules/**', '**/.git/**'],
+                });
+                for (const skillFile of skillFiles) {
+                    const skill = await this.loadSkillFromFile(skillFile);
+                    if (skill && skill.name === skillName) {
+                        this.skillCache.set(skill.name, skill);
+                        return skill.body;
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(`[SkillLoader] Failed to search skill '${skillName}' in ${absoluteSearchPath}:`, err instanceof Error ? err.message : err);
+            }
+        }
+        return null;
+    }
+    /**
+     * Level 3: Load a reference file from a skill's directory.
+     * Reference files are typically in a references/ subdirectory next to SKILL.md.
+     */
+    async loadSkillReference(skillName, referencePath) {
+        const cached = this.skillCache.get(skillName);
+        if (!cached) {
+            return null;
+        }
+        // The skill's location is the SKILL.md file path
+        // References are in the same directory or a references/ subdirectory
+        const skillDir = path.dirname(cached.location);
+        const refAbsolutePath = path.resolve(skillDir, referencePath);
+        try {
+            return await fs.readFile(refAbsolutePath, 'utf-8');
+        }
+        catch {
+            console.warn(`[SkillLoader] Reference file not found: ${refAbsolutePath}`);
+            return null;
+        }
+    }
+    /**
+     * Match a skill by query string against available skills' names and descriptions.
+     * Uses simple keyword matching — finds the skill whose name or description
+     * best matches the query.
+     */
+    matchSkill(query, availableSkills) {
+        if (availableSkills.length === 0) {
+            return null;
+        }
+        const lowerQuery = query.toLowerCase();
+        const queryWords = lowerQuery.split(/\s+/);
+        // Score each skill by how many query words appear in name/description
+        let bestMatch = null;
+        let bestScore = 0;
+        for (const skill of availableSkills) {
+            if (skill.disabled)
+                continue;
+            const searchableText = `${skill.name} ${skill.description}`.toLowerCase();
+            let score = 0;
+            for (const word of queryWords) {
+                if (searchableText.includes(word)) {
+                    score++;
+                }
+            }
+            // Bonus for exact name match
+            if (skill.name.toLowerCase() === lowerQuery) {
+                score += 10;
+            }
+            // Bonus for name being a substring of query
+            if (lowerQuery.includes(skill.name.toLowerCase())) {
+                score += 5;
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                bestMatch = skill;
+            }
+        }
+        return bestMatch;
+    }
+    /**
+     * Get a cached skill definition by name.
+     */
+    getCachedSkill(skillName) {
+        return this.skillCache.get(skillName);
+    }
+    /**
+     * Get all cached skill definitions.
+     */
+    getAllCachedSkills() {
+        return Array.from(this.skillCache.values());
+    }
+    // ===== Private methods =====
+    /**
+     * Load all skills from a directory.
+     * Reference: gemini-cli loadSkillsFromDir (skills/skillLoader.ts L115-159)
+     */
+    async loadSkillsFromDir(dir) {
+        const discoveredSkills = [];
+        try {
+            const absoluteSearchPath = path.resolve(dir);
+            const stats = await fs.stat(absoluteSearchPath).catch(() => null);
+            if (!stats || !stats.isDirectory()) {
+                return [];
+            }
+            const pattern = ['SKILL.md', '*/SKILL.md'];
+            const skillFiles = await (0, glob_1.glob)(pattern, {
+                cwd: absoluteSearchPath,
+                absolute: true,
+                nodir: true,
+                ignore: ['**/node_modules/**', '**/.git/**'],
+            });
+            for (const skillFile of skillFiles) {
+                const skill = await this.loadSkillFromFile(skillFile);
+                if (skill) {
+                    discoveredSkills.push(skill);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`[SkillLoader] Error discovering skills in ${dir}:`, error);
+        }
+        return discoveredSkills;
+    }
+    /**
+     * Load a single skill from a SKILL.md file.
+     * Reference: gemini-cli loadSkillFromFile (skills/skillLoader.ts L164-192)
+     */
+    async loadSkillFromFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const parsed = (0, frontmatter_parser_1.parseSkillFrontmatter)(content);
+            if (!parsed) {
+                return null;
+            }
+            return {
+                name: parsed.name,
+                description: parsed.description,
+                location: filePath,
+                body: parsed.body,
+                allowedTools: parsed.allowedTools,
+                outputType: parsed.outputType,
+            };
+        }
+        catch (error) {
+            console.warn(`[SkillLoader] Error parsing skill file ${filePath}:`, error);
+            return null;
+        }
+    }
+}
+exports.SkillLoader = SkillLoader;

package/dist/tools/ask-user.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ask_user Tool — ask the user a question and wait for confirmation
+ *
+ * Publishes an input_required event via eventBus,
+ * handled by the upper layer (Server) for user interaction.
+ */
+import type { ToolDefinition } from '../agent-loop/types';
+export declare const askUserTool: ToolDefinition;

package/dist/tools/ask-user.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * ask_user Tool — ask the user a question and wait for confirmation
+ *
+ * Publishes an input_required event via eventBus,
+ * handled by the upper layer (Server) for user interaction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askUserTool = void 0;
+const v4_1 = require("zod/v4");
+const AskUserSchema = v4_1.z.object({
+    /** Question to ask the user */
+    question: v4_1.z.string().describe('Question to ask the user'),
+    /** Optional choices for the user */
+    options: v4_1.z.array(v4_1.z.object({
+        label: v4_1.z.string().describe('Option label'),
+        description: v4_1.z.string().optional().describe('Option description'),
+    })).optional().describe('Array of options for the user to choose from'),
+    /** Type of confirmation needed */
+    type: v4_1.z.enum(['confirm', 'choice', 'text']).default('choice').describe('Type: confirm (yes/no), choice (select), text (free input)'),
+});
+exports.askUserTool = {
+    name: 'ask_user',
+    description: `Ask the user a question and wait for their response.
+Use this when:
+- PRD and code implementation are inconsistent and need confirmation
+- Multiple approaches are possible and user preference is needed
+- Information is missing and cannot be determined from available context
+
+The skill execution pauses until the user responds.`,
+    inputSchema: AskUserSchema,
+    async execute(args) {
+        // In AgentLoop mode, this would be handled by the event system
+        // For Phase 1 (hybrid mode), we use a callback approach
+        const callback = globalThis.__askUserCallback;
+        if (callback) {
+            const answer = await callback(args.question, args.options);
+            return { answer, confirmed: true };
+        }
+        // Fallback: no user interaction available — tell LLM to decide on its own
+        console.warn(`[ask_user] No callback registered. Question: ${args.question}`);
+        return {
+            answer: `Unable to reach user. Please decide based on available information and continue. Do not call ask_user again.`,
+            confirmed: true,
+        };
+    },
+};

package/dist/tools/bash.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Bash Tool — shell command execution with scope-based permission control
+ *
+ * Scope patterns (aligned with keve-agent SKILL.md allowed-tools):
+ *   Bash(git:*)   → only git commands allowed
+ *   Bash(npx:*)   → only npx commands allowed
+ *   Bash(npm:*)   → only npm commands allowed
+ *   Bash(node:*)  → only node commands allowed
+ *   Bash(shell:*)  → any command allowed
+ *
+ * When LLM calls bash tool, the 'scope' parameter is validated against
+ * the skill's allowed-tools list by the ToolCaller.
+ */
+import { z } from 'zod/v4';
+import type { ToolDefinition } from '../agent-loop/types';
+export declare const BashInputSchema: z.ZodObject<{
+    command: z.ZodString;
+    scope: z.ZodDefault<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type BashInput = z.infer<typeof BashInputSchema>;
+/**
+ * Validate that a command matches the allowed scope.
+ * Extracts the first word (the binary name) and checks against scope.
+ *
+ * @param command - The shell command to validate
+ * @param allowedScopes - Array of allowed scopes (e.g., ['git', 'npx', 'shell'])
+ * @returns true if command is within allowed scopes
+ */
+export declare function isCommandInScope(command: string, allowedScopes: string[]): boolean;
+/**
+ * Parse Bash(scope:*) patterns from allowed-tools list.
+ * Input: ['Bash(git:*)', 'Bash(npx:*)', 'codegraph_impact']
+ * Output: ['git', 'npx']
+ */
+export declare function parseBashScopes(allowedTools: string[]): string[];
+/**
+ * Check if a command attempts to write to a read-only path.
+ * Uses static analysis of the command string.
+ *
+ * @param command - The shell command to check
+ * @param readOnlyPaths - Array of directory paths that are read-only
+ * @returns Error message if write is detected, or null if command is safe
+ */
+export declare function checkReadOnlyPathWrite(command: string, readOnlyPaths: string[]): string | null;
+export declare const bashTool: ToolDefinition;