distill-mcp 0.6.0-beta

package/dist/sandbox/sdk/git.js

@@ -0,0 +1,313 @@
+/**
+ * SDK Git Functions
+ *
+ * Git operations for sandbox use.
+ * Uses child_process.execSync for git commands.
+ */
+import { execSync } from "child_process";
+import { validatePath } from "../security/path-validator.js";
+const GIT_TIMEOUT = 5000; // 5 seconds
+/**
+ * Blocked git commands that could access network or modify remote state
+ */
+const BLOCKED_GIT_COMMANDS = [
+    "push",
+    "fetch",
+    "pull",
+    "clone",
+    "remote",
+    "submodule",
+    "ls-remote",
+    "archive",
+];
+/**
+ * Sanitize git argument to prevent shell injection
+ */
+function sanitizeGitArg(arg) {
+    // Block shell metacharacters that could enable command injection
+    if (/[;&|`$(){}[\]<>\\!'"]/.test(arg)) {
+        throw new Error(`Invalid git argument: contains shell metacharacters`);
+    }
+    // Block newlines which could inject additional commands
+    if (/[\r\n]/.test(arg)) {
+        throw new Error(`Invalid git argument: contains newlines`);
+    }
+    return arg;
+}
+/**
+ * Validate git command is not blocked
+ */
+function validateGitCommand(command) {
+    const cmd = command.toLowerCase();
+    if (BLOCKED_GIT_COMMANDS.includes(cmd)) {
+        throw new Error(`Git command '${command}' is blocked for security reasons`);
+    }
+}
+/**
+ * Execute git command safely
+ */
+function execGit(args, workingDir) {
+    // Validate the git subcommand
+    if (args.length > 0 && args[0]) {
+        validateGitCommand(args[0]);
+    }
+    // Sanitize all arguments
+    const sanitizedArgs = args.map(sanitizeGitArg);
+    try {
+        const result = execSync(`git ${sanitizedArgs.join(" ")}`, {
+            cwd: workingDir,
+            timeout: GIT_TIMEOUT,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return result.trim();
+    }
+    catch (error) {
+        const err = error;
+        const stderr = err.stderr?.toString().trim() || "";
+        if (stderr.includes("not a git repository")) {
+            throw new Error("Not a git repository");
+        }
+        throw new Error(stderr || err.message || "Git command failed");
+    }
+}
+/**
+ * Parse git diff --numstat output
+ */
+function parseDiffStats(numstat) {
+    const files = [];
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    for (const line of numstat.split("\n")) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        if (parts.length < 3)
+            continue;
+        const addStr = parts[0] ?? "";
+        const delStr = parts[1] ?? "";
+        const file = parts[2] ?? "";
+        const additions = addStr === "-" ? 0 : parseInt(addStr, 10);
+        const deletions = delStr === "-" ? 0 : parseInt(delStr, 10);
+        totalAdditions += additions;
+        totalDeletions += deletions;
+        files.push({
+            file,
+            status: "modified", // Will be refined below
+            additions,
+            deletions,
+        });
+    }
+    return { files, additions: totalAdditions, deletions: totalDeletions };
+}
+/**
+ * Refine file status from diff --name-status
+ */
+function refineFileStatuses(files, nameStatus) {
+    const statusMap = new Map();
+    for (const line of nameStatus.split("\n")) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        const status = parts[0];
+        const file = parts[parts.length - 1]; // Handle renames (R100 old new)
+        if (!status || !file)
+            continue;
+        switch (status[0]) {
+            case "A":
+                statusMap.set(file, "added");
+                break;
+            case "D":
+                statusMap.set(file, "deleted");
+                break;
+            case "R":
+                statusMap.set(file, "renamed");
+                break;
+            default:
+                statusMap.set(file, "modified");
+        }
+    }
+    return files.map((f) => ({
+        ...f,
+        status: statusMap.get(f.file) || f.status,
+    }));
+}
+/**
+ * Parse git log output (custom format)
+ */
+function parseLogOutput(output) {
+    const commits = [];
+    const entries = output.split("\n---COMMIT---\n").filter(Boolean);
+    for (const entry of entries) {
+        const lines = entry.split("\n");
+        if (lines.length < 4)
+            continue;
+        commits.push({
+            hash: lines[0] || "",
+            shortHash: lines[1] || "",
+            author: lines[2] || "",
+            date: lines[3] || "",
+            message: lines.slice(4).join("\n").trim(),
+        });
+    }
+    return commits;
+}
+/**
+ * Parse git blame output (porcelain format)
+ */
+function parseBlameOutput(output) {
+    const lines = [];
+    const chunks = output.split(/^([a-f0-9]{40})/m).filter(Boolean);
+    for (let i = 0; i < chunks.length; i += 2) {
+        const hash = chunks[i];
+        const data = chunks[i + 1] || "";
+        const authorMatch = data.match(/^author (.+)$/m);
+        const dateMatch = data.match(/^author-time (\d+)$/m);
+        const lineMatch = data.match(/^(\d+) \d+ \d+$/m);
+        const contentMatch = data.match(/\t(.*)$/m);
+        const lineNum = lineMatch?.[1];
+        if (hash && lineNum) {
+            const authorTime = dateMatch?.[1];
+            lines.push({
+                hash: hash.slice(0, 7),
+                author: authorMatch?.[1] ?? "Unknown",
+                date: authorTime
+                    ? new Date(parseInt(authorTime, 10) * 1000).toISOString()
+                    : "",
+                line: parseInt(lineNum, 10),
+                content: contentMatch?.[1] ?? "",
+            });
+        }
+    }
+    return lines;
+}
+/**
+ * Parse git status --porcelain output
+ */
+function parseStatusOutput(porcelain, branchInfo) {
+    const staged = [];
+    const modified = [];
+    const untracked = [];
+    for (const line of porcelain.split("\n")) {
+        if (!line.trim())
+            continue;
+        const index = line[0];
+        const worktree = line[1];
+        const file = line.slice(3);
+        if (index === "?") {
+            untracked.push(file);
+        }
+        else if (index !== " ") {
+            staged.push(file);
+        }
+        else if (worktree !== " ") {
+            modified.push(file);
+        }
+    }
+    // Parse branch info: "## main...origin/main [ahead 1, behind 2]"
+    let branch = "HEAD";
+    let ahead = 0;
+    let behind = 0;
+    const branchMatch = branchInfo.match(/^## ([^.]+)/);
+    const branchName = branchMatch?.[1];
+    if (branchName) {
+        branch = branchName;
+    }
+    const aheadMatch = branchInfo.match(/ahead (\d+)/);
+    const aheadNum = aheadMatch?.[1];
+    if (aheadNum) {
+        ahead = parseInt(aheadNum, 10);
+    }
+    const behindMatch = branchInfo.match(/behind (\d+)/);
+    const behindNum = behindMatch?.[1];
+    if (behindNum) {
+        behind = parseInt(behindNum, 10);
+    }
+    return { branch, ahead, behind, staged, modified, untracked };
+}
+/**
+ * Create Git API for sandbox
+ */
+export function createGitAPI(workingDir) {
+    return {
+        /**
+         * Get git diff
+         * @param ref - Optional ref to diff against (default: HEAD)
+         */
+        diff(ref) {
+            const refArg = ref || "HEAD";
+            // Get the raw diff
+            const raw = execGit(["diff", refArg], workingDir);
+            // Get stats
+            const numstat = execGit(["diff", "--numstat", refArg], workingDir);
+            const { files, additions, deletions } = parseDiffStats(numstat);
+            // Get file statuses
+            const nameStatus = execGit(["diff", "--name-status", refArg], workingDir);
+            const refinedFiles = refineFileStatuses(files, nameStatus);
+            return {
+                raw,
+                files: refinedFiles,
+                stats: { additions, deletions },
+            };
+        },
+        /**
+         * Get git log
+         * @param limit - Number of commits to return (default: 10)
+         */
+        log(limit) {
+            const count = Math.min(limit || 10, 100); // Cap at 100
+            const format = "%H%n%h%n%an%n%aI%n%s%n---COMMIT---";
+            const output = execGit(["log", `-${count}`, `--format=${format}`], workingDir);
+            return parseLogOutput(output);
+        },
+        /**
+         * Get git blame for a file
+         * @param file - File path to blame
+         * @param line - Optional specific line number
+         */
+        blame(file, line) {
+            // Validate file path
+            const validation = validatePath(file, workingDir);
+            if (!validation.safe) {
+                throw new Error(validation.error || "Invalid file path");
+            }
+            const args = ["blame", "--porcelain"];
+            if (line !== undefined) {
+                args.push(`-L${line},${line}`);
+            }
+            args.push("--", file);
+            const output = execGit(args, workingDir);
+            return { lines: parseBlameOutput(output) };
+        },
+        /**
+         * Get git status
+         */
+        status() {
+            const porcelain = execGit(["status", "--porcelain"], workingDir);
+            const branchInfo = execGit(["status", "--porcelain", "-b"], workingDir);
+            // First line of -b output is branch info
+            const firstLine = branchInfo.split("\n")[0] || "";
+            return parseStatusOutput(porcelain, firstLine);
+        },
+        /**
+         * Get git branch info
+         */
+        branch() {
+            // Get current branch
+            let current = "";
+            try {
+                current = execGit(["rev-parse", "--abbrev-ref", "HEAD"], workingDir);
+            }
+            catch {
+                current = "HEAD";
+            }
+            // Get all branches
+            const branchOutput = execGit(["branch", "--format=%(refname:short)"], workingDir);
+            const branches = branchOutput
+                .split("\n")
+                .map((b) => b.trim())
+                .filter(Boolean);
+            return { current, branches };
+        },
+    };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Git SDK Tests
+ *
+ * Tests for ctx.git.* functions.
+ * These tests run against the actual git repository.
+ */
+export {};
+//# sourceMappingURL=git.test.d.ts.map

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

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

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

@@ -0,0 +1,160 @@
+/**
+ * Git SDK Tests
+ *
+ * Tests for ctx.git.* functions.
+ * These tests run against the actual git repository.
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { createGitAPI } from "./git.js";
+import { execSync } from "child_process";
+// Check if git is available in the test environment
+function isGitAvailable() {
+    try {
+        execSync("git --version", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Get repository root from git
+function getGitRoot() {
+    try {
+        return execSync("git rev-parse --show-toplevel", {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+const gitAvailable = isGitAvailable();
+const repoRoot = gitAvailable ? getGitRoot() : null;
+describe.skipIf(!gitAvailable || !repoRoot)("Git SDK", () => {
+    let git;
+    beforeAll(() => {
+        git = createGitAPI(repoRoot);
+    });
+    describe("status", () => {
+        it("should return branch name", () => {
+            const status = git.status();
+            expect(status.branch).toBeDefined();
+            expect(typeof status.branch).toBe("string");
+        });
+        it("should return ahead/behind counts", () => {
+            const status = git.status();
+            expect(typeof status.ahead).toBe("number");
+            expect(typeof status.behind).toBe("number");
+        });
+        it("should return file arrays", () => {
+            const status = git.status();
+            expect(Array.isArray(status.staged)).toBe(true);
+            expect(Array.isArray(status.modified)).toBe(true);
+            expect(Array.isArray(status.untracked)).toBe(true);
+        });
+    });
+    describe("branch", () => {
+        it("should return current branch", () => {
+            const branch = git.branch();
+            expect(branch.current).toBeDefined();
+            expect(typeof branch.current).toBe("string");
+        });
+        it("should return branches array", () => {
+            const branch = git.branch();
+            expect(Array.isArray(branch.branches)).toBe(true);
+            expect(branch.branches.length).toBeGreaterThan(0);
+        });
+        it("should include current branch in branches list", () => {
+            const branch = git.branch();
+            expect(branch.branches).toContain(branch.current);
+        });
+    });
+    describe("log", () => {
+        it("should return commit history", () => {
+            const commits = git.log();
+            expect(Array.isArray(commits)).toBe(true);
+            expect(commits.length).toBeGreaterThan(0);
+        });
+        it("should return commits with required fields", () => {
+            const commits = git.log(1);
+            expect(commits.length).toBe(1);
+            const commit = commits[0];
+            expect(commit.hash).toBeDefined();
+            expect(commit.hash.length).toBe(40);
+            expect(commit.shortHash).toBeDefined();
+            expect(commit.shortHash.length).toBe(7);
+            expect(commit.author).toBeDefined();
+            expect(commit.date).toBeDefined();
+            expect(commit.message).toBeDefined();
+        });
+        it("should respect limit parameter", () => {
+            const commits5 = git.log(5);
+            expect(commits5.length).toBeLessThanOrEqual(5);
+            const commits2 = git.log(2);
+            expect(commits2.length).toBeLessThanOrEqual(2);
+        });
+        it("should default to 10 commits", () => {
+            const commits = git.log();
+            expect(commits.length).toBeLessThanOrEqual(10);
+        });
+        it("should cap at 100 commits", () => {
+            const commits = git.log(200);
+            expect(commits.length).toBeLessThanOrEqual(100);
+        });
+    });
+    describe("diff", () => {
+        it("should return diff structure", () => {
+            const diff = git.diff();
+            expect(diff).toBeDefined();
+            expect(typeof diff.raw).toBe("string");
+            expect(Array.isArray(diff.files)).toBe(true);
+            expect(typeof diff.stats.additions).toBe("number");
+            expect(typeof diff.stats.deletions).toBe("number");
+        });
+        it("should return file changes with proper fields", () => {
+            // This test depends on there being changes
+            const diff = git.diff();
+            if (diff.files.length > 0) {
+                const file = diff.files[0];
+                expect(file.file).toBeDefined();
+                expect(["added", "modified", "deleted", "renamed"]).toContain(file.status);
+                expect(typeof file.additions).toBe("number");
+                expect(typeof file.deletions).toBe("number");
+            }
+        });
+    });
+    describe("blame", () => {
+        it("should return blame for existing file", () => {
+            // Test on package.json which should always exist
+            const blame = git.blame("package.json");
+            expect(blame.lines).toBeDefined();
+            expect(Array.isArray(blame.lines)).toBe(true);
+        });
+        it("should return blame lines with proper fields", () => {
+            const blame = git.blame("package.json");
+            if (blame.lines.length > 0) {
+                const line = blame.lines[0];
+                expect(line.hash).toBeDefined();
+                expect(line.author).toBeDefined();
+                expect(typeof line.line).toBe("number");
+            }
+        });
+        it("should support line parameter", () => {
+            const blame = git.blame("package.json", 1);
+            expect(blame.lines.length).toBeLessThanOrEqual(1);
+        });
+        it("should throw for non-existent file", () => {
+            expect(() => git.blame("non-existent-file-xyz.ts")).toThrow();
+        });
+    });
+    describe("error handling", () => {
+        it("should throw for non-git directory", () => {
+            const nonGitApi = createGitAPI("/tmp");
+            expect(() => nonGitApi.status()).toThrow("Not a git repository");
+        });
+    });
+});

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

@@ -0,0 +1,16 @@
+/**
+ * SDK Entry Point
+ *
+ * All SDK functions available in the sandbox.
+ */
+export * from "./compress.js";
+export * from "./code.js";
+export { createFilesAPI } from "./files.js";
+export { createGitAPI } from "./git.js";
+export { createSearchAPI } from "./search.js";
+export { createAnalyzeAPI } from "./analyze.js";
+export { createPipelineAPI } from "./pipeline.js";
+export { createMultifileAPI } from "./multifile.js";
+export { createConversationAPI } from "./conversation.js";
+export * from "./utils.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sandbox/sdk/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,cAAc,YAAY,CAAC"}

package/dist/sandbox/sdk/index.js

@@ -0,0 +1,15 @@
+/**
+ * SDK Entry Point
+ *
+ * All SDK functions available in the sandbox.
+ */
+export * from "./compress.js";
+export * from "./code.js";
+export { createFilesAPI } from "./files.js";
+export { createGitAPI } from "./git.js";
+export { createSearchAPI } from "./search.js";
+export { createAnalyzeAPI } from "./analyze.js";
+export { createPipelineAPI } from "./pipeline.js";
+export { createMultifileAPI } from "./multifile.js";
+export { createConversationAPI } from "./conversation.js";
+export * from "./utils.js";

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

@@ -0,0 +1,63 @@
+/**
+ * SDK Multi-File Functions
+ *
+ * Multi-file compression and analysis for sandbox use.
+ * Provides cross-file deduplication, skeleton extraction, and chunking.
+ */
+import type { HostCallbacks } from "../types.js";
+import { type MultiFileCompressResult, type SharedElements, type ChunkInfo } from "../../compressors/multifile.js";
+/**
+ * SDK Multi-file compress options (simplified)
+ */
+export interface SdkMultiFileOptions {
+    /** Maximum tokens for output */
+    maxTokens?: number;
+    /** Compression strategy */
+    strategy?: "deduplicate" | "skeleton" | "smart-chunk";
+    /** File patterns to preserve fully */
+    preservePatterns?: string[];
+}
+/**
+ * Create multi-file API with host callbacks
+ */
+export declare function createMultifileAPI(workingDir: string, callbacks: HostCallbacks): {
+    /**
+     * Compress multiple files with cross-file deduplication
+     *
+     * @param patterns - Glob patterns for files to include
+     * @param options - Compression options
+     * @returns Compressed result with shared elements and stats
+     */
+    compress(patterns: string[], options?: SdkMultiFileOptions): MultiFileCompressResult;
+    /**
+     * Extract shared elements (imports, types) across files
+     *
+     * @param patterns - Glob patterns for files to analyze
+     * @returns Shared imports, types, and constants
+     */
+    extractShared(patterns: string[]): SharedElements;
+    /**
+     * Create chunks from files for incremental processing
+     *
+     * @param patterns - Glob patterns for files to chunk
+     * @param maxTokensPerChunk - Maximum tokens per chunk
+     * @returns Array of chunk information
+     */
+    chunk(patterns: string[], maxTokensPerChunk: number): ChunkInfo[];
+    /**
+     * Get dependency-aware skeletons for files
+     *
+     * @param patterns - Glob patterns for entry point files
+     * @param depth - Optional depth limit for dependency traversal
+     * @returns Compressed skeleton output
+     */
+    skeletons(patterns: string[], depth?: number): string;
+    /**
+     * Read multiple files into a combined context
+     *
+     * @param patterns - Glob patterns for files to read
+     * @returns Combined file contents with headers
+     */
+    readAll(patterns: string[]): string;
+};
+//# sourceMappingURL=multifile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"multifile.d.ts","sourceRoot":"","sources":["../../../src/sandbox/sdk/multifile.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,OAAO,EAML,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACnB,KAAK,SAAS,EACf,MAAM,gCAAgC,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gCAAgC;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,aAAa,GAAG,UAAU,GAAG,aAAa,CAAC;IACtD,sCAAsC;IACtC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,aAAa;IAmCtB;;;;;;OAMG;uBAES,MAAM,EAAE,YACR,mBAAmB,GAC5B,uBAAuB;IAyB1B;;;;;OAKG;4BACqB,MAAM,EAAE,GAAG,cAAc;IAKjD;;;;;;OAMG;oBACa,MAAM,EAAE,qBAAqB,MAAM,GAAG,SAAS,EAAE;IAKjE;;;;;;OAMG;wBACiB,MAAM,EAAE,UAAU,MAAM,GAAG,MAAM;IAerD;;;;;OAKG;sBACe,MAAM,EAAE,GAAG,MAAM;EAiBtC"}