@crewx/sdk 0.8.0-rc.80 → 0.8.0-rc.83

package/dist/tools/node/builtin.js

@@ -1,547 +0,0 @@
-"use strict";
-/**
- * Built-in tool definitions for api/* provider agents.
- *
- * Adapted from packages/sdk-bak/src/tools/.
- * Uses only Node.js built-ins — no external dependencies.
- *
- * Each entry in BUILTIN_TOOL_REGISTRY matches Omit<ToolDefinition, 'name'>.
- * Register via crewx.registerTool(name, BUILTIN_TOOL_REGISTRY[name]).
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUILTIN_TOOL_REGISTRY = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_child_process_1 = require("node:child_process");
-const node_util_1 = require("node:util");
-const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
-// ─────────────────────────────────────────────────────────────────────────────
-// Shared helpers
-// ─────────────────────────────────────────────────────────────────────────────
-const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next']);
-async function listRecursive(dirPath, basePath, maxDepth = 5, depth = 0) {
-    if (depth >= maxDepth) {
-        return [`${node_path_1.default.relative(basePath, dirPath)}/ (max depth reached)`];
-    }
-    const results = [];
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
-    }
-    catch {
-        return [`${node_path_1.default.relative(basePath, dirPath)}/ (permission denied)`];
-    }
-    for (const entry of entries) {
-        const fullPath = node_path_1.default.join(dirPath, entry.name);
-        const rel = node_path_1.default.relative(basePath, fullPath);
-        if (entry.isDirectory()) {
-            results.push(`${rel}/`);
-            const sub = await listRecursive(fullPath, basePath, maxDepth, depth + 1);
-            results.push(...sub);
-        }
-        else {
-            const s = await promises_1.default.stat(fullPath);
-            results.push(`${rel} (${s.size} bytes)`);
-        }
-    }
-    return results;
-}
-async function buildTreeLines(dirPath, opts) {
-    const { currentDepth, maxDepth } = opts;
-    const indent = '  '.repeat(currentDepth);
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
-    }
-    catch (err) {
-        const code = err.code ?? 'unknown';
-        return [`${indent}(error: ${code})`];
-    }
-    entries.sort((a, b) => {
-        if (a.isDirectory() && !b.isDirectory())
-            return -1;
-        if (!a.isDirectory() && b.isDirectory())
-            return 1;
-        return a.name.localeCompare(b.name);
-    });
-    const lines = [];
-    for (const entry of entries) {
-        const fullPath = node_path_1.default.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-            lines.push(`${indent}[DIR] ${entry.name}/`);
-            if (currentDepth < maxDepth) {
-                const child = await buildTreeLines(fullPath, {
-                    currentDepth: currentDepth + 1,
-                    maxDepth,
-                });
-                lines.push(...child);
-            }
-            else {
-                lines.push(`${'  '.repeat(currentDepth + 1)}(max depth reached)`);
-            }
-        }
-        else {
-            try {
-                const s = await promises_1.default.stat(fullPath);
-                lines.push(`${indent}[FILE] ${entry.name} (${s.size} bytes)`);
-            }
-            catch {
-                lines.push(`${indent}[FILE] ${entry.name} (stat error)`);
-            }
-        }
-    }
-    return lines;
-}
-async function searchFile(filePath, pattern, basePath) {
-    try {
-        const content = await promises_1.default.readFile(filePath, 'utf-8');
-        const lines = content.split('\n');
-        const rel = node_path_1.default.relative(basePath, filePath);
-        return lines.flatMap((line, i) => pattern.test(line) ? [`${rel}:${i + 1}: ${line}`] : []);
-    }
-    catch {
-        return [];
-    }
-}
-async function searchRecursive(dirPath, pattern, basePath, maxDepth = 10, depth = 0) {
-    if (depth >= maxDepth)
-        return [];
-    const results = [];
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    for (const entry of entries) {
-        const fullPath = node_path_1.default.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-            if (!SKIP_DIRS.has(entry.name)) {
-                const sub = await searchRecursive(fullPath, pattern, basePath, maxDepth, depth + 1);
-                results.push(...sub);
-            }
-        }
-        else {
-            const m = await searchFile(fullPath, pattern, basePath);
-            results.push(...m);
-        }
-    }
-    return results;
-}
-function matchWildcard(name, pattern, caseSensitive) {
-    const n = caseSensitive ? name : name.toLowerCase();
-    const p = caseSensitive ? pattern : pattern.toLowerCase();
-    const regexStr = p
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*/g, '.*')
-        .replace(/\?/g, '.');
-    return new RegExp(`^${regexStr}$`).test(n);
-}
-async function findFiles(dirPath, pattern, caseSensitive, results, maxResults, depth = 0) {
-    if (results.length >= maxResults || depth > 10)
-        return;
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        if (results.length >= maxResults)
-            break;
-        const fullPath = node_path_1.default.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-            if (!SKIP_DIRS.has(entry.name)) {
-                await findFiles(fullPath, pattern, caseSensitive, results, maxResults, depth + 1);
-            }
-        }
-        else if (matchWildcard(entry.name, pattern, caseSensitive)) {
-            results.push(fullPath);
-        }
-    }
-}
-function matchGlob(relPath, pattern) {
-    const rel = relPath.replace(/\\/g, '/');
-    const pat = pattern.replace(/\\/g, '/');
-    const regexStr = pat
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-        .replace(/\*\*\//g, '§§§')
-        .replace(/\*\*/g, '§§§')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\?/g, '[^/]')
-        .replace(/§§§/g, '.*');
-    return new RegExp(`^${regexStr}$`).test(rel);
-}
-async function globSearch(dirPath, pattern, basePath, results, maxResults, depth = 0) {
-    if (results.length >= maxResults || depth > 15)
-        return;
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(dirPath, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        if (results.length >= maxResults)
-            break;
-        const fullPath = node_path_1.default.join(dirPath, entry.name);
-        if (entry.isDirectory()) {
-            if (!SKIP_DIRS.has(entry.name)) {
-                await globSearch(fullPath, pattern, basePath, results, maxResults, depth + 1);
-            }
-        }
-        else {
-            const rel = node_path_1.default.relative(basePath, fullPath).replace(/\\/g, '/');
-            if (matchGlob(rel, pattern))
-                results.push(fullPath);
-        }
-    }
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Tool definitions
-// ─────────────────────────────────────────────────────────────────────────────
-const readFileTool = {
-    description: 'Reads and returns the content of a specified file. Use offset/limit to paginate large text files.',
-    parameters: {
-        type: 'object',
-        properties: {
-            file_path: { type: 'string', description: 'Path to the file to read.' },
-            offset: { type: 'integer', description: 'Optional 0-based line number to start reading from.' },
-            limit: { type: 'integer', description: 'Optional maximum number of lines to read.' },
-        },
-        required: ['file_path'],
-    },
-    execute: async (args) => {
-        const filePath = args['file_path'];
-        const offset = args['offset'];
-        const limit = args['limit'];
-        if (!filePath.trim())
-            throw new Error("The 'file_path' parameter must be non-empty.");
-        const resolvedPath = node_path_1.default.resolve(filePath);
-        const content = await promises_1.default.readFile(resolvedPath, 'utf-8');
-        if (offset !== undefined || limit !== undefined) {
-            const lines = content.split('\n');
-            const start = offset ?? 0;
-            const end = limit !== undefined ? start + limit : lines.length;
-            const slice = lines.slice(start, end);
-            const truncated = end < lines.length;
-            const text = slice.join('\n');
-            if (truncated) {
-                return `IMPORTANT: Content truncated. Showing lines ${start}-${end - 1} of ${lines.length}.\n\n${text}`;
-            }
-            return text;
-        }
-        return content;
-    },
-};
-const writeFileTool = {
-    description: 'Creates a new file or overwrites an existing file with the provided content.',
-    parameters: {
-        type: 'object',
-        properties: {
-            file_path: { type: 'string', description: 'Path to the file to create or overwrite.' },
-            content: { type: 'string', description: 'The content to write to the file.' },
-        },
-        required: ['file_path', 'content'],
-    },
-    execute: async (args) => {
-        const filePath = args['file_path'];
-        const content = args['content'];
-        if (!filePath.trim())
-            throw new Error("The 'file_path' parameter must be non-empty.");
-        const resolvedPath = node_path_1.default.resolve(filePath);
-        await promises_1.default.mkdir(node_path_1.default.dirname(resolvedPath), { recursive: true });
-        let fileExists = false;
-        try {
-            await promises_1.default.access(resolvedPath);
-            fileExists = true;
-        }
-        catch { /* file does not exist */ }
-        await promises_1.default.writeFile(resolvedPath, content, 'utf-8');
-        const size = Buffer.byteLength(content, 'utf-8');
-        return `${fileExists ? 'Updated' : 'Created'} file: ${filePath} (${size} bytes)`;
-    },
-};
-const replaceTool = {
-    description: 'Replaces a range of lines in a file with new text. Line numbers are 1-based.',
-    parameters: {
-        type: 'object',
-        properties: {
-            file_path: { type: 'string', description: 'Path to the file to modify.' },
-            start_line: { type: 'integer', description: 'Starting line number (1-based, inclusive).' },
-            end_line: { type: 'integer', description: 'Ending line number (1-based, inclusive).' },
-            new_text: { type: 'string', description: 'New text to insert in place of the specified lines.' },
-        },
-        required: ['file_path', 'start_line', 'end_line', 'new_text'],
-    },
-    execute: async (args) => {
-        const filePath = args['file_path'];
-        const startLine = args['start_line'];
-        const endLine = args['end_line'];
-        const newText = args['new_text'];
-        if (!filePath.trim())
-            throw new Error("The 'file_path' parameter must be non-empty.");
-        if (startLine > endLine) {
-            throw new Error(`start_line (${startLine}) must be <= end_line (${endLine}).`);
-        }
-        const resolvedPath = node_path_1.default.resolve(filePath);
-        const content = await promises_1.default.readFile(resolvedPath, 'utf-8');
-        const lines = content.split('\n');
-        if (startLine < 1 || startLine > lines.length) {
-            throw new Error(`start_line (${startLine}) out of range. File has ${lines.length} lines.`);
-        }
-        if (endLine > lines.length) {
-            throw new Error(`end_line (${endLine}) out of range. File has ${lines.length} lines.`);
-        }
-        const newLines = newText.split('\n');
-        lines.splice(startLine - 1, endLine - startLine + 1, ...newLines);
-        await promises_1.default.writeFile(resolvedPath, lines.join('\n'), 'utf-8');
-        return `Successfully replaced lines ${startLine}-${endLine} in ${filePath}`;
-    },
-};
-const lsTool = {
-    description: "Lists contents of a directory. Shows file sizes and marks directories with trailing slashes.",
-    parameters: {
-        type: 'object',
-        properties: {
-            path: { type: 'string', description: 'Directory path to list (default: current directory).' },
-            recursive: { type: 'boolean', description: 'List contents recursively (default: false).' },
-        },
-    },
-    execute: async (args) => {
-        const dirPath = args['path'] ?? '.';
-        const recursive = args['recursive'] ?? false;
-        const resolvedPath = node_path_1.default.resolve(dirPath);
-        const stats = await promises_1.default.stat(resolvedPath);
-        if (!stats.isDirectory())
-            throw new Error(`Path is not a directory: ${dirPath}`);
-        let output = `Directory listing: ${dirPath}\n\n`;
-        if (recursive) {
-            const entries = await listRecursive(resolvedPath, resolvedPath);
-            output += entries.join('\n');
-        }
-        else {
-            const entries = await promises_1.default.readdir(resolvedPath, { withFileTypes: true });
-            const lines = [];
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    lines.push(`${entry.name}/`);
-                }
-                else {
-                    const s = await promises_1.default.stat(node_path_1.default.join(resolvedPath, entry.name));
-                    lines.push(`${entry.name} (${s.size} bytes)`);
-                }
-            }
-            output += lines.join('\n');
-        }
-        return output || 'Directory is empty';
-    },
-};
-const treeTool = {
-    description: "Displays a directory tree with [DIR]/[FILE] labels up to max_depth levels.",
-    parameters: {
-        type: 'object',
-        properties: {
-            path: { type: 'string', description: 'Directory to inspect (default: current directory).' },
-            max_depth: { type: 'integer', description: 'Maximum depth to traverse (default: 3).' },
-        },
-    },
-    execute: async (args) => {
-        const targetPath = args['path'] ?? '.';
-        const maxDepth = args['max_depth'] ?? 3;
-        const resolvedPath = node_path_1.default.resolve(targetPath);
-        const stats = await promises_1.default.stat(resolvedPath);
-        if (!stats.isDirectory())
-            throw new Error(`Path is not a directory: ${targetPath}`);
-        const relRoot = node_path_1.default.relative(process.cwd(), resolvedPath);
-        const rootLabel = relRoot === '' ? '.' : relRoot;
-        const lines = [
-            `Tree for ${rootLabel} (max depth: ${maxDepth})`,
-            `[DIR] ${rootLabel}/`,
-        ];
-        const treeLines = await buildTreeLines(resolvedPath, { currentDepth: 1, maxDepth });
-        lines.push(...treeLines);
-        return lines.join('\n');
-    },
-};
-const grepTool = {
-    description: 'Searches for a regex pattern in files. Returns matching lines with file paths and line numbers.',
-    parameters: {
-        type: 'object',
-        properties: {
-            pattern: { type: 'string', description: 'Regular expression pattern to search for.' },
-            path: { type: 'string', description: 'File or directory path to search in (default: current directory).' },
-            recursive: { type: 'boolean', description: 'Search recursively through subdirectories (default: true).' },
-        },
-        required: ['pattern'],
-    },
-    execute: async (args) => {
-        const pattern = args['pattern'];
-        const searchPath = args['path'] ?? '.';
-        const recursive = args['recursive'] ?? true;
-        if (!pattern.trim())
-            throw new Error("The 'pattern' parameter must be non-empty.");
-        let regex;
-        try {
-            regex = new RegExp(pattern);
-        }
-        catch (err) {
-            throw new Error(`Invalid regular expression: ${err.message}`);
-        }
-        const resolvedPath = node_path_1.default.resolve(searchPath);
-        const stats = await promises_1.default.stat(resolvedPath);
-        const basePath = stats.isDirectory() ? resolvedPath : node_path_1.default.dirname(resolvedPath);
-        let matches = [];
-        if (stats.isDirectory()) {
-            if (recursive) {
-                matches = await searchRecursive(resolvedPath, regex, basePath);
-            }
-            else {
-                const entries = await promises_1.default.readdir(resolvedPath, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (!entry.isDirectory()) {
-                        const m = await searchFile(node_path_1.default.join(resolvedPath, entry.name), regex, basePath);
-                        matches.push(...m);
-                    }
-                }
-            }
-        }
-        else {
-            matches = await searchFile(resolvedPath, regex, basePath);
-        }
-        if (matches.length === 0)
-            return `No matches found for pattern: ${pattern}`;
-        const maxResults = 100;
-        const limited = matches.slice(0, maxResults);
-        let output = `Found ${matches.length} match(es) for pattern: ${pattern}\n\n${limited.join('\n')}`;
-        if (matches.length > maxResults) {
-            output += `\n\n... and ${matches.length - maxResults} more (output truncated)`;
-        }
-        return output;
-    },
-};
-const findTool = {
-    description: 'Searches for files by filename pattern. Supports * and ? wildcards.',
-    parameters: {
-        type: 'object',
-        properties: {
-            pattern: { type: 'string', description: 'Filename pattern. Supports * and ? wildcards.' },
-            dir_path: { type: 'string', description: 'Directory to search in (default: current directory).' },
-            case_sensitive: { type: 'boolean', description: 'Case-sensitive matching (default: false).' },
-            max_results: { type: 'integer', description: 'Maximum results to return (default: 50).' },
-        },
-        required: ['pattern'],
-    },
-    execute: async (args) => {
-        const pattern = args['pattern'];
-        const dirPath = args['dir_path'] ?? '.';
-        const caseSensitive = args['case_sensitive'] ?? false;
-        const maxResults = args['max_results'] ?? 50;
-        const searchDir = node_path_1.default.resolve(dirPath);
-        const matches = [];
-        await findFiles(searchDir, pattern, caseSensitive, matches, maxResults);
-        if (matches.length === 0) {
-            return `No files found matching pattern: ${pattern}\nSearched in: ${searchDir}`;
-        }
-        const lines = matches.map((p, i) => `  ${i + 1}. ${node_path_1.default.relative(process.cwd(), p)}`);
-        const footer = matches.length >= maxResults ? `\n(Limited to ${maxResults} results)` : '';
-        return `Found ${matches.length} file(s) matching "${pattern}":\n${lines.join('\n')}${footer}`;
-    },
-};
-const globTool = {
-    description: 'Finds files matching glob patterns (e.g., "**/*.ts", "src/**/*.yaml"). Returns file paths.',
-    parameters: {
-        type: 'object',
-        properties: {
-            pattern: { type: 'string', description: 'Glob pattern to match files against.' },
-            dir_path: { type: 'string', description: 'Directory to search in (default: current directory).' },
-            max_results: { type: 'integer', description: 'Maximum results to return (default: 100).' },
-        },
-        required: ['pattern'],
-    },
-    execute: async (args) => {
-        const pattern = args['pattern'];
-        const dirPath = args['dir_path'] ?? '.';
-        const maxResults = args['max_results'] ?? 100;
-        const searchDir = node_path_1.default.resolve(dirPath);
-        const matches = [];
-        await globSearch(searchDir, pattern, searchDir, matches, maxResults);
-        if (matches.length === 0) {
-            return `No files found matching pattern: ${pattern}\nSearched in: ${searchDir}`;
-        }
-        const lines = matches.map((p, i) => `  ${i + 1}. ${node_path_1.default.relative(process.cwd(), p)}`);
-        const footer = matches.length >= maxResults ? `\n(Limited to ${maxResults} results)` : '';
-        return `Found ${matches.length} file(s) matching "${pattern}":\n${lines.join('\n')}${footer}`;
-    },
-};
-const runShellCommandTool = {
-    description: 'Executes a shell command and returns its output (stdout and stderr). Use with caution.',
-    parameters: {
-        type: 'object',
-        properties: {
-            command: { type: 'string', description: 'The shell command to execute.' },
-            timeout_seconds: { type: 'integer', description: 'Maximum execution time in seconds (default: 30).' },
-        },
-        required: ['command'],
-    },
-    execute: async (args) => {
-        const command = args['command'];
-        const timeoutSeconds = args['timeout_seconds'] ?? 30;
-        if (!command.trim())
-            throw new Error("The 'command' parameter must be non-empty.");
-        try {
-            const { stdout, stderr } = await execAsync(command, {
-                timeout: timeoutSeconds * 1000,
-                maxBuffer: 10 * 1024 * 1024,
-                cwd: process.cwd(),
-            });
-            let output = '';
-            if (stdout)
-                output += `STDOUT:\n${stdout}`;
-            if (stderr)
-                output += (stdout ? '\n\n' : '') + `STDERR:\n${stderr}`;
-            return output || 'Command executed successfully (no output)';
-        }
-        catch (err) {
-            const error = err;
-            if (error.killed && error.signal === 'SIGTERM') {
-                throw new Error(`Command timed out after ${timeoutSeconds} seconds`);
-            }
-            let msg = `Command failed: ${command}`;
-            if (error.stdout)
-                msg += `\nSTDOUT:\n${error.stdout}`;
-            if (error.stderr)
-                msg += `\nSTDERR:\n${error.stderr}`;
-            if (error.code !== undefined)
-                msg += `\nExit code: ${error.code}`;
-            throw new Error(msg);
-        }
-    },
-};
-// ─────────────────────────────────────────────────────────────────────────────
-// Registry
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * All available built-in tools, keyed by tool name.
- *
- * Listed tools are registered via crewx.registerTool() when their name appears
- * in crewx.yaml `tools.builtin` for an agent using an api/* provider.
- */
-exports.BUILTIN_TOOL_REGISTRY = {
-    read_file: readFileTool,
-    write_file: writeFileTool,
-    replace: replaceTool,
-    ls: lsTool,
-    tree: treeTool,
-    grep: grepTool,
-    find: findTool,
-    glob: globTool,
-    run_shell_command: runShellCommandTool,
-};
-//# sourceMappingURL=builtin.js.map

package/dist/types/index.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CrewxProjectConfigSchema = exports.AgentConfigSchema = exports.AgentInlineSchema = void 0;
-const zod_1 = require("zod");
-// ─── Agent Config ───────────────────────────────────────────────────────────
-exports.AgentInlineSchema = zod_1.z.object({
-    model: zod_1.z.string().optional(),
-    system_prompt: zod_1.z.string().optional(),
-    prompt: zod_1.z.string().optional(),
-    layout: zod_1.z.union([zod_1.z.string(), zod_1.z.object({ id: zod_1.z.string(), props: zod_1.z.record(zod_1.z.unknown()).optional() })]).optional(),
-}).catchall(zod_1.z.unknown());
-exports.AgentConfigSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    name: zod_1.z.string().optional(),
-    role: zod_1.z.string().optional(),
-    team: zod_1.z.string().optional(),
-    provider: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]),
-    working_directory: zod_1.z.string().optional(),
-    description: zod_1.z.string().optional(),
-    tags: zod_1.z.array(zod_1.z.string()).optional(),
-    inline: exports.AgentInlineSchema.optional(),
-}).catchall(zod_1.z.unknown());
-// ─── Project Config ─────────────────────────────────────────────────────────
-exports.CrewxProjectConfigSchema = zod_1.z.object({
-    agents: zod_1.z.array(exports.AgentConfigSchema).optional(),
-    hooks: zod_1.z.array(zod_1.z.unknown()).optional(),
-    settings: zod_1.z.record(zod_1.z.unknown()).optional(),
-    skills: zod_1.z.unknown().optional(),
-    layouts: zod_1.z.record(zod_1.z.unknown()).optional(),
-    documents: zod_1.z.record(zod_1.z.unknown()).optional(),
-}).catchall(zod_1.z.unknown());
-//# sourceMappingURL=index.js.map

package/dist/types/task-log.types.js

@@ -1,6 +0,0 @@
-"use strict";
-/**
- * Task log types — shared types for task log entries across parsers and server code.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=task-log.types.js.map

package/dist/utils/env-defaults.js

@@ -1,27 +0,0 @@
-"use strict";
-/**
- * Centralized CREWX_* environment variable defaults.
- *
- * Priority: process.env value > hardcoded fallback.
- * No filesystem checks (cwd-dependent paths break in worktrees).
- * Browser-safe: guards process.env / process.cwd() access.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveCrewxCli = resolveCrewxCli;
-exports.resolveCrewxWorkspace = resolveCrewxWorkspace;
-const _env = typeof process !== 'undefined' ? process.env : {};
-/**
- * Resolve CREWX_CLI path.
- * Returns process.env.CREWX_CLI if set, otherwise 'npx crewx'.
- */
-function resolveCrewxCli() {
-    return _env.CREWX_CLI || 'npx crewx';
-}
-/**
- * Resolve CREWX_WORKSPACE path.
- * Returns process.env.CREWX_WORKSPACE if set, otherwise current working directory.
- */
-function resolveCrewxWorkspace() {
-    return _env.CREWX_WORKSPACE || (typeof process !== 'undefined' ? process.cwd() : '/');
-}
-//# sourceMappingURL=env-defaults.js.map

package/dist/utils/glob-match.js

@@ -1,42 +0,0 @@
-"use strict";
-/**
- * Glob pattern matching utilities.
- * Shared by exec helper (security allow/deny) and agent ls filter.
- *
- * '*'  — matches any characters within a single path segment (non-'/').
- * '**' — matches any characters including '/'.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.globToRegex = globToRegex;
-exports.matchesPattern = matchesPattern;
-/**
- * Converts a glob pattern to a RegExp.
- * Handles path-based matching (split by '/') consistent with minimatch behavior.
- */
-function globToRegex(pattern) {
-    const escape = (s) => s.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-    const parts = pattern.split('/');
-    const regexParts = parts.map(part => {
-        if (part === '**') {
-            return '.*';
-        }
-        return part
-            .split('*')
-            .map(escape)
-            .join('[^/]*');
-    });
-    return new RegExp(`^${regexParts.join('\\/')}$`);
-}
-/**
- * Checks if a value matches a glob pattern.
- * Returns false on any regex construction error.
- */
-function matchesPattern(value, pattern) {
-    try {
-        return globToRegex(pattern).test(value);
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=glob-match.js.map