distill-mcp 0.6.0-beta

package/dist/parsers/types.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Build Output Parser Types
+ *
+ * Common types for parsing build tool outputs.
+ */
+export type BuildTool = "tsc" | "eslint" | "webpack" | "vite" | "esbuild" | "rust" | "go" | "generic";
+export type Severity = "error" | "warning" | "info";
+export interface ParsedError {
+    /** Unique signature for grouping (e.g., "TS2304:Cannot find name") */
+    signature: string;
+    /** Error code (e.g., "TS2304", "E0433") */
+    code: string;
+    /** Error message */
+    message: string;
+    /** Source file path */
+    file: string;
+    /** Line number */
+    line: number;
+    /** Column number */
+    column: number;
+    /** Error severity */
+    severity: Severity;
+    /** Original raw line from output */
+    raw: string;
+    /** Additional context (surrounding lines, suggestions) */
+    context?: string;
+}
+export interface ErrorGroup {
+    /** Unique signature */
+    signature: string;
+    /** Error code */
+    code: string;
+    /** Canonical error message */
+    message: string;
+    /** Severity */
+    severity: Severity;
+    /** Total occurrences */
+    count: number;
+    /** First occurrence */
+    firstOccurrence: {
+        file: string;
+        line: number;
+        column: number;
+    };
+    /** All affected files */
+    affectedFiles: string[];
+    /** Sample of raw errors (max 3) */
+    samples: string[];
+    /** Suggested fix if available */
+    suggestion?: string;
+}
+export interface BuildAnalysisResult {
+    /** Detected build tool */
+    buildTool: BuildTool;
+    /** Whether the build succeeded */
+    success: boolean;
+    /** Compressed summary */
+    summary: string;
+    /** Statistics */
+    stats: {
+        totalErrors: number;
+        totalWarnings: number;
+        uniqueErrorTypes: number;
+        uniqueWarningTypes: number;
+        tokensOriginal: number;
+        tokensCompressed: number;
+        reductionPercent: number;
+    };
+    /** Grouped errors */
+    errorGroups: ErrorGroup[];
+    /** Grouped warnings */
+    warningGroups: ErrorGroup[];
+}
+export interface BuildParser {
+    /** Name of the parser */
+    name: string;
+    /** Supported build tools */
+    supportedTools: BuildTool[];
+    /** Check if this parser can handle the output */
+    canParse(output: string): boolean;
+    /** Parse the output and extract errors */
+    parse(output: string): ParsedError[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/parsers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/parsers/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;AAEtG,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpD,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,QAAQ,EAAE,QAAQ,CAAC;IACnB,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,uBAAuB;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe;IACf,QAAQ,EAAE,QAAQ,CAAC;IACnB,wBAAwB;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,eAAe,EAAE;QACf,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,yBAAyB;IACzB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,mCAAmC;IACnC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,iCAAiC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAClC,0BAA0B;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,kCAAkC;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB;IACjB,KAAK,EAAE;QACL,WAAW,EAAE,MAAM,CAAC;QACpB,aAAa,EAAE,MAAM,CAAC;QACtB,gBAAgB,EAAE,MAAM,CAAC;QACzB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,cAAc,EAAE,MAAM,CAAC;QACvB,gBAAgB,EAAE,MAAM,CAAC;QACzB,gBAAgB,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,qBAAqB;IACrB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,uBAAuB;IACvB,aAAa,EAAE,UAAU,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,4BAA4B;IAC5B,cAAc,EAAE,SAAS,EAAE,CAAC;IAC5B,iDAAiD;IACjD,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,0CAA0C;IAC1C,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,EAAE,CAAC;CACtC"}

package/dist/parsers/types.js

@@ -0,0 +1,6 @@
+/**
+ * Build Output Parser Types
+ *
+ * Common types for parsing build tool outputs.
+ */
+export {};

package/dist/parsers/typescript.d.ts

@@ -0,0 +1,8 @@
+/**
+ * TypeScript Error Parser
+ *
+ * Parses TypeScript compiler (tsc) output and extracts structured errors.
+ */
+import type { BuildParser } from "./types.js";
+export declare const typescriptParser: BuildParser;
+//# sourceMappingURL=typescript.d.ts.map

package/dist/parsers/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/parsers/typescript.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAyB,MAAM,YAAY,CAAC;AAwErE,eAAO,MAAM,gBAAgB,EAAE,WAqD9B,CAAC"}

package/dist/parsers/typescript.js

@@ -0,0 +1,107 @@
+/**
+ * TypeScript Error Parser
+ *
+ * Parses TypeScript compiler (tsc) output and extracts structured errors.
+ */
+// TypeScript error format: src/file.ts(12,5): error TS2304: Cannot find name 'foo'.
+const TS_ERROR_PATTERN = /^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s+(TS\d+):\s*(.+)$/;
+// Alternative format: src/file.ts:12:5 - error TS2304: Cannot find name 'foo'.
+const TS_ERROR_ALT_PATTERN = /^(.+?):(\d+):(\d+)\s*-\s*(error|warning)\s+(TS\d+):\s*(.+)$/;
+// Build summary pattern
+const BUILD_SUMMARY_PATTERN = /Found (\d+) errors?/;
+/**
+ * Generate suggestion based on error code
+ */
+function getSuggestion(code, message) {
+    switch (code) {
+        case "TS2304": {
+            const nameMatch = message.match(/Cannot find name '(\w+)'/);
+            if (nameMatch?.[1]) {
+                return `Check if '${nameMatch[1]}' needs to be imported or declared.`;
+            }
+            break;
+        }
+        case "TS2339": {
+            const propMatch = message.match(/Property '(\w+)' does not exist on type '(.+)'/);
+            if (propMatch?.[1] && propMatch[2]) {
+                return `Property '${propMatch[1]}' may have been renamed or removed from type '${propMatch[2]}'.`;
+            }
+            break;
+        }
+        case "TS2345":
+            return "Check the function signature and ensure argument types match.";
+        case "TS2322":
+            return "Verify the types are compatible or add explicit type casting.";
+        case "TS7006":
+            return "Add explicit type annotation to the parameter.";
+        case "TS2307": {
+            const moduleMatch = message.match(/Cannot find module '(.+)'/);
+            if (moduleMatch?.[1]) {
+                return `Install the module with: npm install ${moduleMatch[1].replace(/^@types\//, "")}`;
+            }
+            break;
+        }
+        case "TS1005":
+            return "Check for syntax errors like missing brackets, commas, or semicolons.";
+        case "TS2551":
+            return "Check the suggested name in the error message.";
+    }
+    return undefined;
+}
+/**
+ * Create error signature for grouping
+ */
+function createSignature(code, message) {
+    const normalizedMessage = message
+        .replace(/'[^']+'/g, "'X'")
+        .replace(/\d+/g, "N")
+        .replace(/\s+/g, " ")
+        .trim();
+    return `${code}:${normalizedMessage}`;
+}
+export const typescriptParser = {
+    name: "typescript",
+    supportedTools: ["tsc"],
+    canParse(output) {
+        return (TS_ERROR_PATTERN.test(output) ||
+            TS_ERROR_ALT_PATTERN.test(output) ||
+            output.includes("error TS") ||
+            output.includes("warning TS") ||
+            BUILD_SUMMARY_PATTERN.test(output));
+    },
+    parse(output) {
+        const errors = [];
+        const lines = output.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            // Try main pattern
+            let match = trimmed.match(TS_ERROR_PATTERN);
+            if (!match) {
+                match = trimmed.match(TS_ERROR_ALT_PATTERN);
+            }
+            if (match) {
+                const file = match[1] ?? "unknown";
+                const lineNum = match[2] ?? "0";
+                const colNum = match[3] ?? "0";
+                const severityStr = match[4] ?? "error";
+                const code = match[5] ?? "TS0000";
+                const message = match[6] ?? "Unknown error";
+                const severity = severityStr === "warning" ? "warning" : "error";
+                errors.push({
+                    signature: createSignature(code, message),
+                    code,
+                    message,
+                    file: file.trim(),
+                    line: parseInt(lineNum, 10),
+                    column: parseInt(colNum, 10),
+                    severity,
+                    raw: trimmed,
+                    context: getSuggestion(code, message),
+                });
+            }
+        }
+        return errors;
+    },
+};

package/dist/pipelines/definitions.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pipeline Definitions
+ *
+ * Defines the automatic tool chains for different content types.
+ * Each pipeline is an ordered list of tool names to execute sequentially.
+ */
+import type { ContentType } from "../compressors/types.js";
+/**
+ * Extended content type for pipeline detection
+ */
+export type PipelineContentType = ContentType | "build" | "diff";
+/**
+ * Pipeline definition with metadata
+ */
+export interface PipelineDefinition {
+    /** Ordered list of tool names to execute */
+    tools: string[];
+    /** Human-readable description */
+    description: string;
+    /** Expected token savings range */
+    expectedSavings: string;
+}
+/**
+ * Pipeline definitions by content type
+ *
+ * Each pipeline chains tools that work well together:
+ * - First tool does initial processing
+ * - Subsequent tools refine the output
+ * - Order matters: earlier tools prepare data for later ones
+ */
+export declare const PIPELINE_DEFINITIONS: Record<PipelineContentType, PipelineDefinition>;
+/**
+ * Detect extended content type for pipeline selection
+ *
+ * Uses a scoring-based approach to handle content that might match multiple types.
+ * For example, server logs with errors should be detected as "logs" not "build".
+ */
+export declare function detectPipelineContentType(content: string): PipelineContentType;
+/**
+ * Get the pipeline definition for a content type
+ */
+export declare function getPipelineForType(type: PipelineContentType): PipelineDefinition;
+/**
+ * List all available pipeline types
+ */
+export declare function getAvailablePipelines(): Array<{
+    type: PipelineContentType;
+    definition: PipelineDefinition;
+}>;
+//# sourceMappingURL=definitions.d.ts.map

package/dist/pipelines/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/pipelines/definitions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,OAAO,GAAG,MAAM,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,4CAA4C;IAC5C,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,mBAAmB,EAAE,kBAAkB,CAwEhF,CAAC;AAoEF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,CAkD9E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,kBAAkB,CAEhF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,KAAK,CAAC;IAC7C,IAAI,EAAE,mBAAmB,CAAC;IAC1B,UAAU,EAAE,kBAAkB,CAAC;CAChC,CAAC,CAKD"}

package/dist/pipelines/definitions.js

@@ -0,0 +1,206 @@
+/**
+ * Pipeline Definitions
+ *
+ * Defines the automatic tool chains for different content types.
+ * Each pipeline is an ordered list of tool names to execute sequentially.
+ */
+/**
+ * Pipeline definitions by content type
+ *
+ * Each pipeline chains tools that work well together:
+ * - First tool does initial processing
+ * - Subsequent tools refine the output
+ * - Order matters: earlier tools prepare data for later ones
+ */
+export const PIPELINE_DEFINITIONS = {
+    /**
+     * Build output (npm, tsc, webpack, etc.)
+     * analyze-build-output parses and groups errors
+     * deduplicate-errors removes repeated similar errors
+     */
+    build: {
+        tools: ["analyze_build_output", "deduplicate_errors"],
+        description: "Parse build errors, then deduplicate similar messages",
+        expectedSavings: "90-98%",
+    },
+    /**
+     * Log files (server, application, test output)
+     * summarize-logs extracts key information and groups patterns
+     */
+    logs: {
+        tools: ["summarize_logs"],
+        description: "Summarize log patterns and extract key events",
+        expectedSavings: "80-90%",
+    },
+    /**
+     * Stack traces and error dumps
+     * deduplicate-errors groups similar traces
+     * semantic-compress extracts most important parts
+     */
+    stacktrace: {
+        tools: ["deduplicate_errors", "semantic_compress"],
+        description: "Group similar errors, then extract important content",
+        expectedSavings: "70-85%",
+    },
+    /**
+     * Git diffs
+     * diff-compress with auto-selected strategy
+     */
+    diff: {
+        tools: ["diff_compress"],
+        description: "Compress git diff output",
+        expectedSavings: "50-95%",
+    },
+    /**
+     * Configuration files (JSON, YAML, TOML)
+     * compress-context handles structured data
+     */
+    config: {
+        tools: ["compress_context"],
+        description: "Compress configuration data",
+        expectedSavings: "30-60%",
+    },
+    /**
+     * Source code
+     * semantic-compress extracts important code sections
+     */
+    code: {
+        tools: ["semantic_compress"],
+        description: "Extract important code sections",
+        expectedSavings: "40-60%",
+    },
+    /**
+     * Generic content (fallback)
+     * semantic-compress using TF-IDF scoring
+     */
+    generic: {
+        tools: ["semantic_compress"],
+        description: "Apply semantic compression",
+        expectedSavings: "40-60%",
+    },
+};
+/**
+ * Detection patterns for extended content types
+ */
+/**
+ * Log patterns - used for scoring log-like content
+ * These patterns match individual lines, not the whole content
+ */
+const LOG_LINE_PATTERNS = [
+    /^\[\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}/, // [2025-12-23 10:15:23]
+    /^\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}/, // 2025-12-23 10:15:23
+    /^\[\w+\]\s+(INFO|WARN|WARNING|ERROR|DEBUG|TRACE|FATAL)[\s:]/i, // [tag] INFO:
+    /^(INFO|WARN|WARNING|ERROR|DEBUG|TRACE|FATAL)[\s:\[]/i, // INFO: at start
+    /^\d{2}:\d{2}:\d{2}[.,]\d{3}\s+(INFO|WARN|ERROR|DEBUG)/i, // 10:15:23.456 INFO
+    /^time="[^"]+"\s+level=/, // logrus style
+    /^{"(level|time|timestamp|msg)":/, // JSON logs
+    /^\[[A-Z]+\]\s*\d{4}-\d{2}-\d{2}/, // [INFO] 2025-12-23
+    /^\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}/, // syslog: Dec 23 10:15:23
+    /^\w{3}\s{1,2}\d{1,2}\s+\d{2}:\d{2}:\d{2}/, // syslog with padding: Dec  3 10:15:23
+    /^<\d+>\w{3}\s+\d{1,2}/, // syslog with priority: <134>Dec 23
+    /^<\d+>\d/, // syslog priority with timestamp
+    /\|\s*(INFO|WARN|ERROR|DEBUG|TRACE)\s*\|/i, // | INFO | format
+    /\s(INFO|WARN|WARNING|ERROR|DEBUG|TRACE|FATAL):\s/i, // embedded log level: "app: ERROR: msg"
+    /^\S+\s+\S+\[\d+\]:/, // daemon format: app[1234]:
+];
+/**
+ * Build error patterns - specific error formats from compilers/bundlers
+ * These are very specific to build tools, not general error messages
+ */
+const BUILD_LINE_PATTERNS = [
+    /error TS\d+:/i, // TypeScript: error TS2304
+    /error\[E\d+\]:/i, // Rust: error[E0425]
+    /:\d+:\d+:\s*error:/i, // GCC/Clang: file:10:5: error:
+    /\(\d+,\d+\):\s*error/i, // C#/TS: file(10,5): error
+    /npm ERR!/i, // npm specific
+    /ENOENT:|EACCES:|EPERM:/i, // Node.js errors
+    /Module not found.*Can't resolve/i, // Webpack
+    /SyntaxError:.*unexpected token/i, // Parse errors
+    /ModuleNotFoundError: No module named/i, // Python
+    /error: aborting due to/i, // Rust
+    /FAILURE: Build failed/i, // Gradle
+    /BUILD FAILED/i, // Ant/Maven
+    /error CS\d+:/i, // C# compiler
+];
+const DIFF_PATTERNS = [
+    /^diff --git/m, // Git diff header
+    /^@@\s*-\d+,?\d*\s*\+\d+,?\d*\s*@@/m, // Unified diff hunk
+    /^---\s+a\//m, // Git diff file marker
+    /^\+\+\+\s+b\//m, // Git diff file marker
+];
+/**
+ * Count how many lines match any of the given patterns
+ */
+function countMatchingLines(lines, patterns) {
+    let count = 0;
+    for (const line of lines) {
+        if (patterns.some((p) => p.test(line))) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Detect extended content type for pipeline selection
+ *
+ * Uses a scoring-based approach to handle content that might match multiple types.
+ * For example, server logs with errors should be detected as "logs" not "build".
+ */
+export function detectPipelineContentType(content) {
+    // Check for diff first (very specific pattern, no ambiguity)
+    if (DIFF_PATTERNS.some((p) => p.test(content))) {
+        return "diff";
+    }
+    // Split into lines for scoring
+    const lines = content.split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length === 0) {
+        return "generic";
+    }
+    // Count matches for each type
+    const logMatches = countMatchingLines(lines, LOG_LINE_PATTERNS);
+    const buildMatches = countMatchingLines(lines, BUILD_LINE_PATTERNS);
+    // Calculate percentages
+    const logPercent = logMatches / lines.length;
+    const buildPercent = buildMatches / lines.length;
+    // If we have significant log patterns (>10% of lines), prefer logs
+    // This handles the case where logs contain some error messages
+    if (logPercent >= 0.1 && logMatches >= 2) {
+        // Even if there are some build-like patterns, if log patterns are dominant, it's logs
+        if (logMatches >= buildMatches || logPercent >= 0.2) {
+            return "logs";
+        }
+    }
+    // Strong build signal: specific compiler errors (even a few are significant)
+    if (buildMatches >= 1 && buildPercent >= 0.05) {
+        // Make sure it's not actually logs with some errors
+        // Build output typically has concentrated errors, not spread throughout
+        if (buildMatches > logMatches || logPercent < 0.1) {
+            return "build";
+        }
+    }
+    // Fallback: if we have any log patterns, treat as logs
+    if (logMatches > 0) {
+        return "logs";
+    }
+    // If we have build patterns but didn't trigger above, still treat as build
+    if (buildMatches > 0) {
+        return "build";
+    }
+    // Fall back to generic
+    return "generic";
+}
+/**
+ * Get the pipeline definition for a content type
+ */
+export function getPipelineForType(type) {
+    return PIPELINE_DEFINITIONS[type] ?? PIPELINE_DEFINITIONS.generic;
+}
+/**
+ * List all available pipeline types
+ */
+export function getAvailablePipelines() {
+    return Object.entries(PIPELINE_DEFINITIONS).map(([type, definition]) => ({
+        type: type,
+        definition,
+    }));
+}

package/dist/sandbox/executor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Sandbox Executor
+ *
+ * Executes user code in a sandboxed environment with ctxopt SDK.
+ * Uses Function constructor with restricted scope for isolation.
+ */
+import type { ExecutionContext, ExecutionResult } from "./types.js";
+/**
+ * Execute code in sandbox
+ */
+export declare function executeSandbox(code: string, context: ExecutionContext): Promise<ExecutionResult>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/sandbox/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/sandbox/executor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AA0BH,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EAIhB,MAAM,YAAY,CAAC;AAmHpB;;GAEG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CA6E1B"}

package/dist/sandbox/executor.js

@@ -0,0 +1,191 @@
+/**
+ * Sandbox Executor
+ *
+ * Executes user code in a sandboxed environment with ctxopt SDK.
+ * Uses Function constructor with restricted scope for isolation.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { compressAuto, compressLogs, compressDiff, compressSemantic, codeParse, codeExtract, codeSkeleton, countTokens, detectType, detectLanguage, createFilesAPI, createGitAPI, createSearchAPI, createAnalyzeAPI, createPipelineAPI, createMultifileAPI, createConversationAPI, } from "./sdk/index.js";
+import { analyzeCode, sanitizeError } from "./security/index.js";
+import { validatePath, validateGlobPattern } from "./security/path-validator.js";
+/**
+ * Create host callbacks for file operations
+ */
+function createHostCallbacks(workingDir) {
+    return {
+        readFile(filePath) {
+            const validation = validatePath(filePath, workingDir);
+            if (!validation.safe) {
+                throw new Error(validation.error || "Invalid path");
+            }
+            return fs.readFileSync(validation.resolvedPath, "utf-8");
+        },
+        fileExists(filePath) {
+            const validation = validatePath(filePath, workingDir);
+            if (!validation.safe) {
+                return false;
+            }
+            try {
+                fs.accessSync(validation.resolvedPath);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        glob(pattern) {
+            const validation = validateGlobPattern(pattern, workingDir);
+            if (!validation.safe) {
+                throw new Error(validation.error || "Invalid glob pattern");
+            }
+            // Synchronous glob using fs
+            const results = [];
+            const searchDir = path.dirname(validation.resolvedPath);
+            const basePattern = path.basename(pattern);
+            function walkDir(dir, relativePath = "") {
+                try {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const fullPath = path.join(dir, entry.name);
+                        const relPath = path.join(relativePath, entry.name);
+                        if (entry.isDirectory()) {
+                            if (pattern.includes("**")) {
+                                walkDir(fullPath, relPath);
+                            }
+                        }
+                        else if (entry.isFile()) {
+                            // Simple glob matching
+                            if (matchesPattern(entry.name, basePattern)) {
+                                results.push(relPath);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Skip directories we can't read
+                }
+            }
+            walkDir(workingDir);
+            return results.slice(0, 100); // Limit results
+        },
+    };
+}
+/**
+ * Simple glob pattern matching
+ */
+function matchesPattern(filename, pattern) {
+    // Handle common patterns
+    if (pattern === "*")
+        return true;
+    if (pattern.startsWith("*.")) {
+        const ext = pattern.slice(1);
+        return filename.endsWith(ext);
+    }
+    return filename === pattern;
+}
+/**
+ * Create the SDK object for sandbox
+ */
+function createSDK(workingDir) {
+    const callbacks = createHostCallbacks(workingDir);
+    const filesAPI = createFilesAPI(callbacks);
+    return {
+        compress: {
+            auto: compressAuto,
+            logs: compressLogs,
+            diff: compressDiff,
+            semantic: compressSemantic,
+        },
+        code: {
+            parse: codeParse,
+            extract: codeExtract,
+            skeleton: codeSkeleton,
+        },
+        files: filesAPI,
+        utils: {
+            countTokens,
+            detectType,
+            detectLanguage,
+        },
+        git: createGitAPI(workingDir),
+        search: createSearchAPI(workingDir, callbacks),
+        analyze: createAnalyzeAPI(workingDir, callbacks),
+        pipeline: createPipelineAPI(workingDir, callbacks),
+        multifile: createMultifileAPI(workingDir, callbacks),
+        conversation: createConversationAPI(workingDir, callbacks),
+    };
+}
+/**
+ * Execute code in sandbox
+ */
+export async function executeSandbox(code, context) {
+    const startTime = Date.now();
+    // Security: analyze code before execution
+    const analysis = analyzeCode(code);
+    if (!analysis.safe) {
+        return {
+            success: false,
+            output: null,
+            error: `Blocked patterns: ${analysis.blockedPatterns.join(", ")}`,
+            stats: {
+                executionTimeMs: Date.now() - startTime,
+                tokensUsed: 0,
+            },
+        };
+    }
+    try {
+        // Create SDK
+        const ctx = createSDK(context.workingDir);
+        // Wrap code in async function
+        const wrappedCode = `
+      return (async function() {
+        ${code}
+      })();
+    `;
+        // Create sandboxed function
+        // Note: This is not fully isolated, but provides some protection
+        const sandboxedFn = new Function("ctx", wrappedCode);
+        // Execute with timeout
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error("Execution timeout")), context.timeout);
+        });
+        const result = await Promise.race([sandboxedFn(ctx), timeoutPromise]);
+        // Count output tokens
+        const outputStr = JSON.stringify(result, null, 2);
+        const tokensUsed = countTokens(outputStr);
+        // Check output size
+        if (tokensUsed > context.maxOutputTokens) {
+            // Auto-compress large output
+            const compressed = compressAuto(outputStr);
+            return {
+                success: true,
+                output: compressed.compressed,
+                stats: {
+                    executionTimeMs: Date.now() - startTime,
+                    tokensUsed: compressed.stats.compressed,
+                },
+            };
+        }
+        return {
+            success: true,
+            output: result,
+            stats: {
+                executionTimeMs: Date.now() - startTime,
+                tokensUsed,
+            },
+        };
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return {
+            success: false,
+            output: null,
+            error: sanitizeError(err, context.workingDir),
+            stats: {
+                executionTimeMs: Date.now() - startTime,
+                tokensUsed: 0,
+            },
+        };
+    }
+}