distill-mcp 0.6.0-beta

package/dist/sandbox/sdk/pipeline.test.js

@@ -0,0 +1,197 @@
+/**
+ * Pipeline SDK Tests
+ *
+ * Tests for ctx.pipeline.* functions.
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { createPipelineAPI } from "./pipeline.js";
+import * as fs from "fs";
+import * as path from "path";
+// Get the monorepo root
+function getProjectRoot() {
+    let dir = __dirname;
+    while (dir !== "/" && !fs.existsSync(path.join(dir, "package.json"))) {
+        dir = path.dirname(dir);
+    }
+    return dir;
+}
+const projectRoot = getProjectRoot();
+// Create mock callbacks
+function createMockCallbacks(workingDir) {
+    return {
+        readFile(filePath) {
+            const fullPath = path.isAbsolute(filePath)
+                ? filePath
+                : path.join(workingDir, filePath);
+            return fs.readFileSync(fullPath, "utf-8");
+        },
+        fileExists(filePath) {
+            const fullPath = path.isAbsolute(filePath)
+                ? filePath
+                : path.join(workingDir, filePath);
+            try {
+                fs.accessSync(fullPath);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        glob() {
+            return [];
+        },
+    };
+}
+describe("Pipeline SDK", () => {
+    let pipeline;
+    beforeAll(() => {
+        const callbacks = createMockCallbacks(projectRoot);
+        pipeline = createPipelineAPI(projectRoot, callbacks);
+    });
+    describe("executePipeline", () => {
+        it("should execute glob step", () => {
+            const result = pipeline([{ glob: "**/*.ts" }]);
+            expect(result).toBeDefined();
+            expect(result.data).toBeDefined();
+            expect(Array.isArray(result.data)).toBe(true);
+            expect(result.stats.stepsExecuted).toBe(1);
+        });
+        it("should execute filter step", () => {
+            const result = pipeline([
+                { glob: "**/*.ts" },
+                { filter: (f) => String(f).includes("test") },
+            ]);
+            expect(result.stats.stepsExecuted).toBe(2);
+            const files = result.data;
+            expect(files.every((f) => f.includes("test"))).toBe(true);
+        });
+        it("should execute limit step", () => {
+            const result = pipeline([{ glob: "**/*.ts" }, { limit: 5 }]);
+            expect(result.stats.stepsExecuted).toBe(2);
+            const files = result.data;
+            expect(files.length).toBeLessThanOrEqual(5);
+        });
+        it("should execute sort step", () => {
+            const result = pipeline([
+                { glob: "**/*.ts" },
+                { limit: 10 },
+                { sort: "asc" },
+            ]);
+            expect(result.stats.stepsExecuted).toBe(3);
+            const files = result.data;
+            // Verify sorted ascending
+            for (let i = 1; i < files.length; i++) {
+                expect(files[i] >= files[i - 1]).toBe(true);
+            }
+        });
+        it("should execute unique step", () => {
+            const result = pipeline([
+                { glob: "**/*.ts" },
+                { unique: true },
+            ]);
+            expect(result.stats.stepsExecuted).toBe(2);
+            const files = result.data;
+            const uniqueSet = new Set(files);
+            expect(files.length).toBe(uniqueSet.size);
+        });
+        it("should return stats with execution time", () => {
+            const result = pipeline([{ glob: "**/*.ts" }, { limit: 5 }]);
+            expect(result.stats).toBeDefined();
+            expect(typeof result.stats.executionTimeMs).toBe("number");
+            expect(result.stats.executionTimeMs).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe("codebaseOverview", () => {
+        it("should return CodebaseOverview structure", () => {
+            const result = pipeline.codebaseOverview("src/sandbox/sdk");
+            expect(result).toBeDefined();
+            expect(typeof result.totalFiles).toBe("number");
+            expect(typeof result.totalLines).toBe("number");
+            expect(result.languages).toBeDefined();
+            expect(Array.isArray(result.largestFiles)).toBe(true);
+            expect(result.structure).toBeDefined();
+        });
+        it("should count files and lines", () => {
+            const result = pipeline.codebaseOverview("src/sandbox/sdk");
+            expect(result.totalFiles).toBeGreaterThan(0);
+            expect(result.totalLines).toBeGreaterThan(0);
+        });
+        it("should detect languages", () => {
+            const result = pipeline.codebaseOverview("src/sandbox/sdk");
+            expect(result.languages.typescript).toBeGreaterThan(0);
+        });
+        it("should list largest files", () => {
+            const result = pipeline.codebaseOverview("src/sandbox/sdk");
+            expect(result.largestFiles.length).toBeGreaterThan(0);
+            const firstFile = result.largestFiles[0];
+            expect(firstFile.path).toBeDefined();
+            expect(typeof firstFile.lines).toBe("number");
+        });
+        it("should build structure tree", () => {
+            const result = pipeline.codebaseOverview("src/sandbox/sdk");
+            expect(result.structure.type).toBe("directory");
+            expect(result.structure.name).toBe("sdk");
+            expect(result.structure.children).toBeDefined();
+        });
+    });
+    describe("findUsages", () => {
+        it("should return SymbolUsage structure", () => {
+            const result = pipeline.findUsages("createPipelineAPI");
+            expect(result).toBeDefined();
+            expect(result.symbol).toBe("createPipelineAPI");
+            expect(Array.isArray(result.definitions)).toBe(true);
+            expect(Array.isArray(result.usages)).toBe(true);
+            expect(typeof result.totalReferences).toBe("number");
+        });
+        it("should find definitions", () => {
+            const result = pipeline.findUsages("createPipelineAPI");
+            expect(result.definitions.length).toBeGreaterThan(0);
+            const def = result.definitions[0];
+            expect(def.file).toBeDefined();
+            expect(typeof def.line).toBe("number");
+        });
+        it("should find usages", () => {
+            // Use a symbol that should have usages
+            const result = pipeline.findUsages("PipelineStep");
+            expect(result.totalReferences).toBeGreaterThan(0);
+        });
+        it("should support glob filter", () => {
+            const result = pipeline.findUsages("createPipelineAPI", "**/*.ts");
+            expect(result.symbol).toBe("createPipelineAPI");
+            expect(result.totalReferences).toBeGreaterThan(0);
+        });
+    });
+    describe("analyzeDeps", () => {
+        it("should return DependencyAnalysis structure", () => {
+            const result = pipeline.analyzeDeps("src/sandbox/sdk/pipeline.ts");
+            expect(result).toBeDefined();
+            expect(result.file).toBe("src/sandbox/sdk/pipeline.ts");
+            expect(Array.isArray(result.directDeps)).toBe(true);
+            expect(Array.isArray(result.transitiveDeps)).toBe(true);
+            expect(Array.isArray(result.externalPackages)).toBe(true);
+            expect(Array.isArray(result.circularDeps)).toBe(true);
+        });
+        it("should find external packages", () => {
+            const result = pipeline.analyzeDeps("src/sandbox/sdk/pipeline.ts");
+            // pipeline.ts imports fs and path
+            expect(result.externalPackages).toContain("fs");
+            expect(result.externalPackages).toContain("path");
+        });
+        it("should find direct dependencies", () => {
+            const result = pipeline.analyzeDeps("src/sandbox/sdk/pipeline.ts");
+            // pipeline.ts imports from ../types.js and ./compress.js
+            expect(result.directDeps.length).toBeGreaterThanOrEqual(0);
+        });
+        it("should respect depth parameter", () => {
+            const shallow = pipeline.analyzeDeps("src/sandbox/sdk/pipeline.ts", 1);
+            const deep = pipeline.analyzeDeps("src/sandbox/sdk/pipeline.ts", 3);
+            // Deep should potentially have more transitive deps
+            expect(shallow.directDeps.length).toBeLessThanOrEqual(shallow.directDeps.length + deep.transitiveDeps.length);
+        });
+    });
+    describe("error handling", () => {
+        it("should throw for invalid glob pattern", () => {
+            expect(() => pipeline([{ glob: "../../../etc/passwd" }])).toThrow();
+        });
+    });
+});

package/dist/sandbox/sdk/search.d.ts

@@ -0,0 +1,36 @@
+/**
+ * SDK Search Functions
+ *
+ * Code search operations for sandbox use.
+ * Provides grep, symbol search, file search, and reference finding.
+ */
+import type { GrepResult, SymbolResult, FileResult, ReferenceMatch, HostCallbacks } from "../types.js";
+/**
+ * Create Search API for sandbox
+ */
+export declare function createSearchAPI(workingDir: string, callbacks: HostCallbacks): {
+    /**
+     * Search for pattern in files (grep-style)
+     * @param pattern - Regex pattern to search for
+     * @param glob - Optional glob pattern to filter files (default: all supported code files)
+     */
+    grep(pattern: string, glob?: string): GrepResult;
+    /**
+     * Search for symbols (functions, classes, etc.) across files
+     * @param query - Symbol name to search for (supports partial match)
+     * @param glob - Optional glob pattern to filter files
+     */
+    symbols(query: string, glob?: string): SymbolResult;
+    /**
+     * Search for files by pattern
+     * @param pattern - Glob pattern to match files
+     */
+    files(pattern: string): FileResult;
+    /**
+     * Find references to a symbol
+     * @param symbol - Symbol name to find references for
+     * @param glob - Optional glob pattern to filter files
+     */
+    references(symbol: string, glob?: string): ReferenceMatch[];
+};
+//# sourceMappingURL=search.d.ts.map

package/dist/sandbox/sdk/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/sandbox/sdk/search.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAEV,UAAU,EAEV,YAAY,EAEZ,UAAU,EACV,cAAc,EACd,aAAa,EACd,MAAM,aAAa,CAAC;AA0GrB;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa;IAExE;;;;OAIG;kBACW,MAAM,SAAS,MAAM,GAAG,UAAU;IAmDhD;;;;OAIG;mBACY,MAAM,SAAS,MAAM,GAAG,YAAY;IAuEnD;;;OAGG;mBACY,MAAM,GAAG,UAAU;IAoClC;;;;OAIG;uBACgB,MAAM,SAAS,MAAM,GAAG,cAAc,EAAE;EA+F9D"}

package/dist/sandbox/sdk/search.js

@@ -0,0 +1,338 @@
+/**
+ * SDK Search Functions
+ *
+ * Code search operations for sandbox use.
+ * Provides grep, symbol search, file search, and reference finding.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { parseFile } from "../../ast/index.js";
+import { detectLanguageFromPath } from "../../utils/language-detector.js";
+import { validateGlobPattern } from "../security/path-validator.js";
+const MAX_RESULTS = 100;
+const MAX_FILES_TO_SEARCH = 500;
+const MAX_FILE_SIZE = 1024 * 1024; // 1MB
+/**
+ * Simple glob pattern matcher
+ */
+function matchGlob(filepath, pattern) {
+    // Convert glob pattern to regex
+    const regexPattern = pattern
+        .replace(/\./g, "\\.")
+        .replace(/\*\*/g, "{{DOUBLESTAR}}")
+        .replace(/\*/g, "[^/]*")
+        .replace(/{{DOUBLESTAR}}/g, ".*")
+        .replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(filepath);
+}
+/**
+ * Walk directory and find matching files
+ */
+function walkDirectory(dir, pattern, workingDir, maxFiles = MAX_FILES_TO_SEARCH) {
+    const results = [];
+    function walk(currentDir, relativePath = "") {
+        if (results.length >= maxFiles)
+            return;
+        try {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (results.length >= maxFiles)
+                    break;
+                const fullPath = path.join(currentDir, entry.name);
+                const relPath = path.join(relativePath, entry.name);
+                // Skip hidden directories and node_modules
+                if (entry.name.startsWith(".") || entry.name === "node_modules") {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    walk(fullPath, relPath);
+                }
+                else if (entry.isFile()) {
+                    if (matchGlob(relPath, pattern)) {
+                        results.push(relPath);
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    walk(dir);
+    return results;
+}
+/**
+ * Search for pattern in file content
+ */
+function searchInFile(filePath, content, pattern) {
+    const matches = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        let match;
+        // Reset lastIndex for global regex
+        pattern.lastIndex = 0;
+        while ((match = pattern.exec(line)) !== null) {
+            matches.push({
+                file: filePath,
+                line: i + 1,
+                column: match.index + 1,
+                content: line.trim(),
+                match: match[0],
+            });
+            // Prevent infinite loop for zero-length matches
+            if (match[0].length === 0)
+                break;
+        }
+    }
+    return matches;
+}
+/**
+ * Create Search API for sandbox
+ */
+export function createSearchAPI(workingDir, callbacks) {
+    return {
+        /**
+         * Search for pattern in files (grep-style)
+         * @param pattern - Regex pattern to search for
+         * @param glob - Optional glob pattern to filter files (default: all supported code files)
+         */
+        grep(pattern, glob) {
+            const filePattern = glob ?? "**/*.{ts,tsx,js,jsx,py,go,rs,php,swift}";
+            // Validate glob pattern
+            const validation = validateGlobPattern(filePattern, workingDir);
+            if (!validation.safe) {
+                throw new Error(validation.error ?? "Invalid glob pattern");
+            }
+            // Find matching files
+            const files = walkDirectory(workingDir, filePattern, workingDir);
+            const allMatches = [];
+            // Create regex from pattern
+            let regex;
+            try {
+                regex = new RegExp(pattern, "g");
+            }
+            catch {
+                throw new Error(`Invalid regex pattern: ${pattern}`);
+            }
+            // Search each file
+            for (const file of files) {
+                if (allMatches.length >= MAX_RESULTS)
+                    break;
+                try {
+                    const fullPath = path.join(workingDir, file);
+                    const stats = fs.statSync(fullPath);
+                    // Skip large files
+                    if (stats.size > MAX_FILE_SIZE)
+                        continue;
+                    const content = fs.readFileSync(fullPath, "utf-8");
+                    const matches = searchInFile(file, content, regex);
+                    for (const match of matches) {
+                        if (allMatches.length >= MAX_RESULTS)
+                            break;
+                        allMatches.push(match);
+                    }
+                }
+                catch {
+                    // Skip files we can't read
+                }
+            }
+            return {
+                matches: allMatches,
+                totalMatches: allMatches.length,
+                filesSearched: files.length,
+            };
+        },
+        /**
+         * Search for symbols (functions, classes, etc.) across files
+         * @param query - Symbol name to search for (supports partial match)
+         * @param glob - Optional glob pattern to filter files
+         */
+        symbols(query, glob) {
+            const filePattern = glob ?? "**/*.{ts,tsx,js,jsx,py,go,rs,php,swift}";
+            // Validate glob pattern
+            const validation = validateGlobPattern(filePattern, workingDir);
+            if (!validation.safe) {
+                throw new Error(validation.error ?? "Invalid glob pattern");
+            }
+            // Find matching files
+            const files = walkDirectory(workingDir, filePattern, workingDir);
+            const allSymbols = [];
+            const queryLower = query.toLowerCase();
+            // Parse each file and search for symbols
+            for (const file of files) {
+                if (allSymbols.length >= MAX_RESULTS)
+                    break;
+                try {
+                    const fullPath = path.join(workingDir, file);
+                    const stats = fs.statSync(fullPath);
+                    // Skip large files
+                    if (stats.size > MAX_FILE_SIZE)
+                        continue;
+                    const content = fs.readFileSync(fullPath, "utf-8");
+                    const language = detectLanguageFromPath(file);
+                    if (language === "unknown")
+                        continue;
+                    const structure = parseFile(content, language);
+                    // Search in all symbol types
+                    const symbolTypes = [
+                        { type: "function", elements: structure.functions },
+                        { type: "class", elements: structure.classes },
+                        { type: "interface", elements: structure.interfaces },
+                        { type: "type", elements: structure.types },
+                        { type: "variable", elements: structure.variables },
+                    ];
+                    for (const { type, elements } of symbolTypes) {
+                        for (const element of elements) {
+                            if (allSymbols.length >= MAX_RESULTS)
+                                break;
+                            if (element.name.toLowerCase().includes(queryLower)) {
+                                allSymbols.push({
+                                    name: element.name,
+                                    type,
+                                    file,
+                                    line: element.startLine,
+                                    signature: element.signature,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Skip files we can't parse
+                }
+            }
+            return {
+                symbols: allSymbols,
+                totalMatches: allSymbols.length,
+            };
+        },
+        /**
+         * Search for files by pattern
+         * @param pattern - Glob pattern to match files
+         */
+        files(pattern) {
+            // Validate glob pattern
+            const validation = validateGlobPattern(pattern, workingDir);
+            if (!validation.safe) {
+                throw new Error(validation.error ?? "Invalid glob pattern");
+            }
+            // Find matching files
+            const files = walkDirectory(workingDir, pattern, workingDir);
+            const fileMatches = [];
+            for (const file of files) {
+                if (fileMatches.length >= MAX_RESULTS)
+                    break;
+                try {
+                    const fullPath = path.join(workingDir, file);
+                    const stats = fs.statSync(fullPath);
+                    const parsed = path.parse(file);
+                    fileMatches.push({
+                        path: file,
+                        name: parsed.base,
+                        extension: parsed.ext,
+                        size: stats.size,
+                    });
+                }
+                catch {
+                    // Skip files we can't stat
+                }
+            }
+            return {
+                files: fileMatches,
+                totalMatches: fileMatches.length,
+            };
+        },
+        /**
+         * Find references to a symbol
+         * @param symbol - Symbol name to find references for
+         * @param glob - Optional glob pattern to filter files
+         */
+        references(symbol, glob) {
+            const filePattern = glob ?? "**/*.{ts,tsx,js,jsx,py,go,rs,php,swift}";
+            // Validate glob pattern
+            const validation = validateGlobPattern(filePattern, workingDir);
+            if (!validation.safe) {
+                throw new Error(validation.error ?? "Invalid glob pattern");
+            }
+            // Find matching files
+            const files = walkDirectory(workingDir, filePattern, workingDir);
+            const references = [];
+            // Create patterns for different reference types
+            // Definition: function/class/const/let/var name
+            const defPattern = new RegExp(`(?:function|class|const|let|var|interface|type)\\s+${escapeRegex(symbol)}\\b`, "g");
+            // Import: import { name } or import name
+            const importPattern = new RegExp(`import\\s+(?:{[^}]*\\b${escapeRegex(symbol)}\\b[^}]*}|${escapeRegex(symbol)})`, "g");
+            // Usage: general word boundary match (excluding definitions)
+            const usagePattern = new RegExp(`\\b${escapeRegex(symbol)}\\b`, "g");
+            for (const file of files) {
+                if (references.length >= MAX_RESULTS)
+                    break;
+                try {
+                    const fullPath = path.join(workingDir, file);
+                    const stats = fs.statSync(fullPath);
+                    // Skip large files
+                    if (stats.size > MAX_FILE_SIZE)
+                        continue;
+                    const content = fs.readFileSync(fullPath, "utf-8");
+                    const lines = content.split("\n");
+                    for (let i = 0; i < lines.length; i++) {
+                        if (references.length >= MAX_RESULTS)
+                            break;
+                        const line = lines[i] ?? "";
+                        // Check for definition
+                        defPattern.lastIndex = 0;
+                        let match = defPattern.exec(line);
+                        if (match) {
+                            references.push({
+                                file,
+                                line: i + 1,
+                                column: match.index + 1,
+                                context: line.trim(),
+                                type: "definition",
+                            });
+                            continue; // Don't double-count as usage
+                        }
+                        // Check for import
+                        importPattern.lastIndex = 0;
+                        match = importPattern.exec(line);
+                        if (match) {
+                            references.push({
+                                file,
+                                line: i + 1,
+                                column: match.index + 1,
+                                context: line.trim(),
+                                type: "import",
+                            });
+                            continue;
+                        }
+                        // Check for usage
+                        usagePattern.lastIndex = 0;
+                        while ((match = usagePattern.exec(line)) !== null) {
+                            if (references.length >= MAX_RESULTS)
+                                break;
+                            references.push({
+                                file,
+                                line: i + 1,
+                                column: match.index + 1,
+                                context: line.trim(),
+                                type: "usage",
+                            });
+                        }
+                    }
+                }
+                catch {
+                    // Skip files we can't read
+                }
+            }
+            return references;
+        },
+    };
+}
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/sandbox/sdk/search.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Search SDK Tests
+ *
+ * Tests for ctx.search.* functions.
+ */
+export {};
+//# sourceMappingURL=search.test.d.ts.map

package/dist/sandbox/sdk/search.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.test.d.ts","sourceRoot":"","sources":["../../../src/sandbox/sdk/search.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}