flowseeker 0.1.7

package/dist/adapters/frameworkEdges.js

@@ -0,0 +1,586 @@
+"use strict";
+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.detectFramework = detectFramework;
+exports.getFrameworkExtractor = getFrameworkExtractor;
+const path = __importStar(require("path"));
+const text_1 = require("../utils/text");
+function detectFramework(relativePath, content) {
+    const ext = path.extname(relativePath).toLowerCase();
+    if (ext === ".php") {
+        return "laravel";
+    }
+    if (ext === ".py") {
+        return "django";
+    }
+    if ((ext === ".ts" || ext === ".js") && content) {
+        if (/@(?:Controller|Module|Injectable|Get|Post|Put|Delete|Patch)\s*\(/.test(content)) {
+            return "nestjs";
+        }
+        if (/\b(?:express|router\.(?:get|post|put|delete|patch)|app\.(?:get|post|put|delete|patch))\s*\(/.test(content)) {
+            return "express";
+        }
+    }
+    if (ext === ".py" && content) {
+        if (/\b(?:urlpatterns|path\s*\(|re_path\s*\()/.test(content)) {
+            return "django";
+        }
+    }
+    return undefined;
+}
+function getFrameworkExtractor(framework) {
+    return extractors[framework];
+}
+const extractors = {
+    laravel: createLaravelExtractor(),
+    nestjs: createNestJsExtractor(),
+    express: createExpressExtractor(),
+    django: createDjangoExtractor()
+};
+function createLaravelExtractor() {
+    return {
+        name: "laravel",
+        extensions: [".php"],
+        extractEdges(files) {
+            const edges = [];
+            const classToPath = new Map();
+            const pathToUnitIds = new Map();
+            for (const file of files) {
+                pathToUnitIds.set(file.relativePath, file.unitIds);
+                const ns = extractNamespace(file.content);
+                const className = extractClassName(file.content);
+                if (ns && className) {
+                    classToPath.set(`${ns}\\${className}`, file.relativePath);
+                    classToPath.set(className, file.relativePath);
+                }
+            }
+            for (const file of files) {
+                const fileUnitIds = file.unitIds;
+                function addEdges(targetPath, edgeType, weight) {
+                    if (!targetPath || targetPath === file.relativePath) {
+                        return;
+                    }
+                    const targetIds = pathToUnitIds.get(targetPath);
+                    if (targetIds && targetIds.length > 0) {
+                        for (const fromId of fileUnitIds) {
+                            for (const toId of targetIds) {
+                                edges.push({ from: fromId, to: toId, type: edgeType, weight });
+                            }
+                        }
+                    }
+                    else if (fileUnitIds.length > 0) {
+                        const syntheticTargetId = `${targetPath}:1:1:code_region:fw`;
+                        for (const fromId of fileUnitIds) {
+                            edges.push({ from: fromId, to: syntheticTargetId, type: edgeType, weight });
+                        }
+                    }
+                }
+                // Route → Controller edges
+                const controllerRefs = extractRouteControllers(file.content);
+                for (const ref of controllerRefs) {
+                    addEdges(resolvePhpClass(ref, classToPath, file.relativePath, ["Controller"]), "framework_route_handler", 5);
+                }
+                // Event → Listener/Event edges
+                const eventDispatches = extractEventDispatches(file.content);
+                for (const eventClass of eventDispatches) {
+                    addEdges(resolvePhpClass(eventClass, classToPath, file.relativePath, ["Event"]), "framework_event_dispatch", 4);
+                }
+                // Controller → Service (DI injection)
+                const injectedServices = extractConstructorInjection(file.content);
+                for (const serviceClass of injectedServices) {
+                    addEdges(resolvePhpClass(serviceClass, classToPath, file.relativePath, ["Service", "Repository"]), "framework_service_dependency", 3);
+                }
+                // Job::dispatch → Job class
+                const jobDispatches = extractJobDispatches(file.content);
+                for (const jobClass of jobDispatches) {
+                    addEdges(resolvePhpClass(jobClass, classToPath, file.relativePath, ["Job"]), "framework_job_dispatch", 4);
+                }
+                // Config usage → config files
+                const configKeys = extractConfigKeys(file.content);
+                for (const key of configKeys) {
+                    const configFile = resolveConfigFile(key);
+                    addEdges(configFile, "framework_config_usage", 3);
+                }
+                // View rendering → template files
+                const viewRefs = extractViewRenders(file.content);
+                for (const viewName of viewRefs) {
+                    const templatePath = resolveViewPath(viewName);
+                    addEdges(templatePath, "framework_view_render", 5);
+                }
+            }
+            return edges;
+        }
+    };
+}
+function extractNamespace(content) {
+    const match = content.match(/namespace\s+([A-Za-z0-9_\\]+)\s*;/);
+    return match?.[1] ?? undefined;
+}
+function extractClassName(content) {
+    const match = content.match(/class\s+(\w+)\s*(?:extends|implements|\{|$)/m);
+    return match?.[1] ?? undefined;
+}
+function extractRouteControllers(content) {
+    const refs = [];
+    const pattern = /\[(\w+)::class\s*,\s*'(\w+)'\]/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return refs;
+}
+function extractEventDispatches(content) {
+    const refs = [];
+    const pattern = /event\s*\(\s*new\s+(\w+)\s*\(/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return refs;
+}
+function extractConstructorInjection(content) {
+    const refs = [];
+    const pattern = /(?:private|protected|public)\s+(?:readonly\s+)?(\w+)\s+\$\w+/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return refs;
+}
+function extractJobDispatches(content) {
+    const refs = [];
+    const pattern = /(\w+)::dispatch\s*\(/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return refs;
+}
+function extractConfigKeys(content) {
+    const refs = [];
+    const pattern = /config\s*\(\s*['"]([^'"]+)['"]/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return refs;
+}
+function extractViewRenders(content) {
+    const refs = [];
+    const viewFuncPattern = /view\s*\(\s*['"]([^'"]+)['"]/g;
+    let match = viewFuncPattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = viewFuncPattern.exec(content);
+    }
+    const viewPropPattern = /view:\s*['"]([^'"]+)['"]/g;
+    match = viewPropPattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = viewPropPattern.exec(content);
+    }
+    return refs;
+}
+function resolveViewPath(viewName) {
+    const parts = viewName.replace(/\./g, "/");
+    return `resources/views/${parts}.blade.php`;
+}
+function resolvePhpClass(className, classToPath, sourcePath, suffixHints) {
+    const direct = classToPath.get(className);
+    if (direct) {
+        return direct;
+    }
+    for (const [fqcn, filePath] of classToPath) {
+        const base = fqcn.split("\\").pop() ?? "";
+        const normalized = (0, text_1.normalizeText)(base);
+        const target = (0, text_1.normalizeText)(className);
+        if (normalized === target && filePath !== sourcePath) {
+            return filePath;
+        }
+    }
+    return undefined;
+}
+function resolveConfigFile(configKey) {
+    const parts = configKey.split(".");
+    const firstPart = parts[0];
+    const configFiles = ["mail", "app", "database", "cache", "queue", "services", "auth", "session", "logging", "filesystems"];
+    if (configFiles.includes(firstPart)) {
+        return `config/${firstPart}.php`;
+    }
+    return "config/app.php";
+}
+function createNestJsExtractor() {
+    return {
+        name: "nestjs",
+        extensions: [".ts", ".js"],
+        extractEdges(files) {
+            const edges = [];
+            const classToPath = new Map();
+            const pathToUnitIds = new Map();
+            for (const file of files) {
+                pathToUnitIds.set(file.relativePath, file.unitIds);
+                const className = extractTsClassName(file.content);
+                if (className) {
+                    classToPath.set(className, file.relativePath);
+                }
+            }
+            for (const file of files) {
+                const fileUnitIds = file.unitIds;
+                function addEdges(targetPath, edgeType, weight) {
+                    if (!targetPath || targetPath === file.relativePath) {
+                        return;
+                    }
+                    const targetIds = pathToUnitIds.get(targetPath);
+                    if (targetIds && targetIds.length > 0) {
+                        for (const fromId of fileUnitIds) {
+                            for (const toId of targetIds) {
+                                edges.push({ from: fromId, to: toId, type: edgeType, weight });
+                            }
+                        }
+                    }
+                    else if (fileUnitIds.length > 0) {
+                        const syntheticTargetId = `${targetPath}:1:1:code_region:fw`;
+                        for (const fromId of fileUnitIds) {
+                            edges.push({ from: fromId, to: syntheticTargetId, type: edgeType, weight });
+                        }
+                    }
+                }
+                // NestJS Controller → Service (constructor DI)
+                const diTypes = extractNestDiTypes(file.content);
+                for (const typeName of diTypes) {
+                    const targetPath = classToPath.get(typeName) ?? guessTsFilePath(typeName, file.relativePath);
+                    addEdges(targetPath, "framework_service_dependency", 3);
+                }
+                // NestJS Module → Controller/Provider references
+                const moduleRefs = extractNestModuleRefs(file.content);
+                for (const refName of moduleRefs) {
+                    const targetPath = classToPath.get(refName) ?? guessTsFilePath(refName, file.relativePath);
+                    addEdges(targetPath, "framework_route_handler", 4);
+                }
+            }
+            return edges;
+        }
+    };
+}
+function createExpressExtractor() {
+    return {
+        name: "express",
+        extensions: [".ts", ".js"],
+        extractEdges(files) {
+            const edges = [];
+            const pathToUnitIds = new Map();
+            for (const file of files) {
+                pathToUnitIds.set(file.relativePath, file.unitIds);
+            }
+            for (const file of files) {
+                const fileUnitIds = file.unitIds;
+                function addEdges(targetPath, edgeType, weight) {
+                    if (!targetPath || targetPath === file.relativePath) {
+                        return;
+                    }
+                    const targetIds = pathToUnitIds.get(targetPath);
+                    if (targetIds && targetIds.length > 0) {
+                        for (const fromId of fileUnitIds) {
+                            for (const toId of targetIds) {
+                                edges.push({ from: fromId, to: toId, type: edgeType, weight });
+                            }
+                        }
+                    }
+                    else if (fileUnitIds.length > 0) {
+                        const syntheticTargetId = `${targetPath}:1:1:code_region:fw`;
+                        for (const fromId of fileUnitIds) {
+                            edges.push({ from: fromId, to: syntheticTargetId, type: edgeType, weight });
+                        }
+                    }
+                }
+                // Express route handlers: router.get('/path', handlerFn)
+                // The handler is often imported from a controller file
+                const routeRequires = extractExpressRequires(file.content);
+                for (const requirePath of routeRequires) {
+                    const resolved = resolveRequirePath(requirePath, file.relativePath);
+                    addEdges(resolved, "framework_route_handler", 4);
+                }
+            }
+            return edges;
+        }
+    };
+}
+function extractTsClassName(content) {
+    const match = content.match(/(?:export\s+)?class\s+(\w+)/);
+    return match?.[1] ?? undefined;
+}
+function extractNestDiTypes(content) {
+    const types = [];
+    const pattern = /constructor\s*\([\s\S]*?\)\s*[{:]/g;
+    let match = pattern.exec(content);
+    while (match) {
+        const params = match[0];
+        const paramPattern = /(?:private|protected|public)\s+(?:readonly\s+)?(\w+)\s*:/g;
+        let paramMatch = paramPattern.exec(params);
+        while (paramMatch) {
+            types.push(paramMatch[1]);
+            paramMatch = paramPattern.exec(params);
+        }
+        match = pattern.exec(content);
+    }
+    return types;
+}
+function extractNestModuleRefs(content) {
+    const refs = [];
+    const controllersMatch = content.match(/controllers\s*:\s*\[([^\]]+)\]/);
+    if (controllersMatch) {
+        const names = controllersMatch[1].match(/(\w+)/g) ?? [];
+        refs.push(...names);
+    }
+    const providersMatch = content.match(/providers\s*:\s*\[([^\]]+)\]/);
+    if (providersMatch) {
+        const names = providersMatch[1].match(/(\w+)/g) ?? [];
+        refs.push(...names);
+    }
+    return refs;
+}
+function extractExpressRequires(content) {
+    const refs = [];
+    const pattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    const importPattern = /\bfrom\s+['"]([^'"]+)['"]/g;
+    match = importPattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = importPattern.exec(content);
+    }
+    return refs;
+}
+function guessTsFilePath(className, sourcePath) {
+    const sourceDir = sourcePath.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
+    if (className.endsWith("Service")) {
+        return `${sourceDir}/${className}.ts`;
+    }
+    if (className.endsWith("Controller")) {
+        return `${sourceDir}/${className}.ts`;
+    }
+    return undefined;
+}
+function resolveRequirePath(requirePath, sourcePath) {
+    const sourceDir = sourcePath.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
+    const resolved = requirePath.replace(/^\.\//, `${sourceDir}/`).replace(/^\.\.\//, `${sourceDir}/../`);
+    if (!resolved.includes("/")) {
+        return `src/${resolved}.ts`;
+    }
+    if (!resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
+        return `${resolved}.ts`;
+    }
+    return resolved;
+}
+function createDjangoExtractor() {
+    return {
+        name: "django",
+        extensions: [".py"],
+        extractEdges(files) {
+            const edges = [];
+            const pathToUnitIds = new Map();
+            const viewToPath = new Map();
+            const modelToPath = new Map();
+            for (const file of files) {
+                pathToUnitIds.set(file.relativePath, file.unitIds);
+                const models = extractDjangoModelNames(file.content);
+                for (const model of models) {
+                    modelToPath.set(model, file.relativePath);
+                }
+                const views = extractDjangoViewNames(file.content);
+                for (const view of views) {
+                    viewToPath.set(view, file.relativePath);
+                }
+            }
+            for (const file of files) {
+                const fileUnitIds = file.unitIds;
+                function addEdges(targetPath, edgeType, weight) {
+                    if (!targetPath || targetPath === file.relativePath) {
+                        return;
+                    }
+                    const targetIds = pathToUnitIds.get(targetPath);
+                    if (targetIds && targetIds.length > 0) {
+                        for (const fromId of fileUnitIds) {
+                            for (const toId of targetIds) {
+                                edges.push({ from: fromId, to: toId, type: edgeType, weight });
+                            }
+                        }
+                    }
+                    else if (fileUnitIds.length > 0) {
+                        const syntheticTargetId = `${targetPath}:1:1:code_region:fw`;
+                        for (const fromId of fileUnitIds) {
+                            edges.push({ from: fromId, to: syntheticTargetId, type: edgeType, weight });
+                        }
+                    }
+                }
+                // URL patterns → View functions/classes
+                const urlViewRefs = extractDjangoUrlViews(file.content);
+                for (const viewName of urlViewRefs) {
+                    const targetPath = viewToPath.get(viewName) ?? guessDjangoFilePath(viewName, file.relativePath);
+                    addEdges(targetPath, "framework_route_handler", 4);
+                }
+                // View → Model usage (objects.filter/get/create)
+                const modelRefs = extractDjangoModelRefs(file.content);
+                for (const modelName of modelRefs) {
+                    const targetPath = modelToPath.get(modelName) ?? guessDjangoFilePath(modelName, file.relativePath);
+                    addEdges(targetPath, "framework_service_dependency", 3);
+                }
+                // View → Template rendering: render(request, 'template.html')
+                const templateRefs = extractDjangoTemplateRefs(file.content);
+                for (const template of templateRefs) {
+                    addEdges(`templates/${template}`, "framework_view_render", 5);
+                }
+                // Celery task dispatch: task.delay(...)
+                const celeryTasks = extractCeleryTaskDispatches(file.content);
+                for (const taskName of celeryTasks) {
+                    const targetPath = guessDjangoFilePath(taskName, file.relativePath);
+                    addEdges(targetPath, "framework_job_dispatch", 4);
+                }
+                // Settings usage: settings.EMAIL_HOST
+                const settingsRefs = extractDjangoSettingsRefs(file.content);
+                if (settingsRefs.length > 0) {
+                    const settingsPath = guessDjangoFilePath("settings", file.relativePath);
+                    addEdges(settingsPath, "framework_config_usage", 3);
+                }
+            }
+            return edges;
+        }
+    };
+}
+function extractDjangoModelNames(content) {
+    const models = [];
+    const pattern = /class\s+(\w+)\s*\(\s*(?:models\.Model|Model)\s*\)/g;
+    let match = pattern.exec(content);
+    while (match) {
+        models.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return models;
+}
+function extractDjangoViewNames(content) {
+    const views = [];
+    const classPattern = /class\s+(\w+)\s*\([^)]*View[^)]*\)/g;
+    let match = classPattern.exec(content);
+    while (match) {
+        views.push(match[1]);
+        match = classPattern.exec(content);
+    }
+    const funcPattern = /def\s+(\w+)\s*\(\s*(?:request|self)/g;
+    match = funcPattern.exec(content);
+    while (match) {
+        views.push(match[1]);
+        match = funcPattern.exec(content);
+    }
+    return views;
+}
+function extractDjangoUrlViews(content) {
+    const refs = [];
+    const pattern = /(?:path|re_path)\s*\([^,]+,\s*(?:(\w+)\.as_view\(\)|(\w+))\s*,/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1] ?? match[2]);
+        match = pattern.exec(content);
+    }
+    return refs;
+}
+function extractDjangoModelRefs(content) {
+    const refs = [];
+    const pattern = /(\w+)\.objects\.(?:filter|get|create|all|update|delete|exclude)\s*\(/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return [...new Set(refs)];
+}
+function extractDjangoTemplateRefs(content) {
+    const refs = [];
+    const pattern = /render\s*\(\s*(?:request|self\.request)\s*,\s*['"]([^'"]+)['"]/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return refs;
+}
+function extractCeleryTaskDispatches(content) {
+    const refs = [];
+    const pattern = /(\w+)\.(?:delay|apply_async|s)\s*\(/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return [...new Set(refs)];
+}
+function extractDjangoSettingsRefs(content) {
+    const refs = [];
+    const pattern = /(?:settings|django\.conf\.settings)\.(\w+)/g;
+    let match = pattern.exec(content);
+    while (match) {
+        refs.push(match[1]);
+        match = pattern.exec(content);
+    }
+    return refs;
+}
+function guessDjangoFilePath(name, sourcePath) {
+    const sourceDir = sourcePath.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
+    const lower = name.toLowerCase();
+    if (lower === "settings")
+        return `${sourceDir}/settings.py`;
+    if (/\b(?:view|controller)\b/i.test(lower))
+        return `${sourceDir}/views.py`;
+    if (/\bmodel\b/i.test(lower))
+        return `${sourceDir}/models.py`;
+    if (/\btask\b/i.test(lower))
+        return `${sourceDir}/tasks.py`;
+    if (/\bserializer\b/i.test(lower))
+        return `${sourceDir}/serializers.py`;
+    if (/\bform\b/i.test(lower))
+        return `${sourceDir}/forms.py`;
+    if (/\burl\b/i.test(lower))
+        return `${sourceDir}/urls.py`;
+    return `${sourceDir}/${name}.py`;
+}
+//# sourceMappingURL=frameworkEdges.js.map

package/dist/agent/approvalPolicy.js

@@ -0,0 +1,81 @@
+"use strict";
+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.getApprovalPolicy = getApprovalPolicy;
+exports.canAutoApprove = canAutoApprove;
+exports.classifyCommand = classifyCommand;
+const vscode = __importStar(require("vscode"));
+function getApprovalPolicy() {
+    const config = vscode.workspace.getConfiguration("flowseeker");
+    return {
+        readWorkspace: config.get("agent.autoApprove.readWorkspace", true),
+        editWorkspace: config.get("agent.autoApprove.editWorkspace", false),
+        safeCommands: config.get("agent.autoApprove.safeCommands", false),
+        allCommands: config.get("agent.autoApprove.allCommands", false),
+        mcpTools: config.get("agent.autoApprove.mcpTools", false),
+        rules: config.get("agent.rules", [])
+    };
+}
+function canAutoApprove(kind, policy = getApprovalPolicy()) {
+    switch (kind) {
+        case "read_workspace":
+            return policy.readWorkspace;
+        case "edit_workspace":
+            return policy.editWorkspace;
+        case "safe_command":
+            return policy.safeCommands || policy.allCommands;
+        case "all_command":
+            return policy.allCommands;
+        case "mcp_tool":
+            return policy.mcpTools;
+    }
+}
+function classifyCommand(command) {
+    const normalized = command.trim().toLowerCase();
+    if (!normalized) {
+        return { safe: false, destructive: false, reason: "Empty command." };
+    }
+    if (/\b(rm|del|erase|rmdir|remove-item|move-item|mv|git\s+reset|git\s+clean|format|mkfs|shutdown|reboot)\b/.test(normalized)) {
+        return { safe: false, destructive: true, reason: "Command contains a destructive operation." };
+    }
+    if (/[>;|&]/.test(normalized) && /\b(rm|del|erase|remove-item|git\s+reset|git\s+clean)\b/.test(normalized)) {
+        return { safe: false, destructive: true, reason: "Chained command includes a destructive operation." };
+    }
+    if (/^(git status|git diff|git log|git show|npm test|npm run test|npm run compile|npm run build|npm run lint|pnpm test|pnpm build|pnpm lint|yarn test|yarn build|yarn lint|cargo test|cargo check|go test|pytest|ruff check|tsc\b)/.test(normalized)) {
+        return { safe: true, destructive: false, reason: "Command matches a known read/build/test pattern." };
+    }
+    return { safe: false, destructive: false, reason: "Command is not in the safe allowlist." };
+}
+//# sourceMappingURL=approvalPolicy.js.map