@wavexzore/sandbox 0.1.0

package/dist/sandbox/core/edit/filediff.js

@@ -0,0 +1,21 @@
+import { diffLines } from 'diff';
+import { createWriteDiff } from '../write/diff.js';
+import { normalizeLineEndings } from './line-endings.js';
+export function createFileDiff(input) {
+    let additions = 0;
+    let deletions = 0;
+    const oldContent = normalizeLineEndings(input.oldContent);
+    const newContent = normalizeLineEndings(input.newContent);
+    for (const change of diffLines(oldContent, newContent)) {
+        if (change.added)
+            additions += change.count ?? 0;
+        if (change.removed)
+            deletions += change.count ?? 0;
+    }
+    return {
+        file: input.file,
+        patch: createWriteDiff({ oldPath: input.file, newPath: input.file, oldContent, newContent }),
+        additions,
+        deletions,
+    };
+}

package/dist/sandbox/core/edit/index.d.ts

@@ -0,0 +1,5 @@
+export * from './filediff.js';
+export * from './line-endings.js';
+export * from './lock.js';
+export * from './replace.js';
+export * from './replacers.js';

package/dist/sandbox/core/edit/index.js

@@ -0,0 +1,5 @@
+export * from './filediff.js';
+export * from './line-endings.js';
+export * from './lock.js';
+export * from './replace.js';
+export * from './replacers.js';

package/dist/sandbox/core/edit/line-endings.d.ts

@@ -0,0 +1,4 @@
+export type LineEnding = '\n' | '\r\n';
+export declare function normalizeLineEndings(text: string): string;
+export declare function detectLineEnding(text: string): LineEnding;
+export declare function convertToLineEnding(text: string, ending: LineEnding): string;

package/dist/sandbox/core/edit/line-endings.js

@@ -0,0 +1,10 @@
+export function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+export function detectLineEnding(text) {
+    return text.includes('\r\n') ? '\r\n' : '\n';
+}
+export function convertToLineEnding(text, ending) {
+    const normalized = normalizeLineEndings(text);
+    return ending === '\r\n' ? normalized.replace(/\n/g, '\r\n') : normalized;
+}

package/dist/sandbox/core/edit/lock.d.ts

@@ -0,0 +1 @@
+export declare function withFileLock<T>(key: string, fn: () => Promise<T>): Promise<T>;

package/dist/sandbox/core/edit/lock.js

@@ -0,0 +1,18 @@
+const queues = new Map();
+export async function withFileLock(key, fn) {
+    const previous = queues.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    queues.set(key, previous.then(() => current, () => current));
+    await previous.catch(() => undefined);
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (queues.get(key) === current)
+            queues.delete(key);
+    }
+}

package/dist/sandbox/core/edit/replace.d.ts

@@ -0,0 +1,10 @@
+export type AppliedEdit = {
+    content: string;
+    search?: string;
+};
+export declare function applyOpenCodeEdit(input: {
+    content: string;
+    oldString: string;
+    newString: string;
+    replaceAll?: boolean;
+}): AppliedEdit;

package/dist/sandbox/core/edit/replace.js

@@ -0,0 +1,14 @@
+import { convertToLineEnding, detectLineEnding, normalizeLineEndings } from './line-endings.js';
+import { replaceWithFallbacks } from './replacers.js';
+export function applyOpenCodeEdit(input) {
+    if (input.oldString === input.newString) {
+        throw new Error('No changes to apply: oldString and newString are identical.');
+    }
+    if (input.oldString === '')
+        return { content: input.newString };
+    const ending = detectLineEnding(input.content);
+    const normalizedContent = convertToLineEnding(normalizeLineEndings(input.content), ending);
+    const oldString = convertToLineEnding(normalizeLineEndings(input.oldString), ending);
+    const newString = convertToLineEnding(normalizeLineEndings(input.newString), ending);
+    return replaceWithFallbacks(normalizedContent, oldString, newString, input.replaceAll);
+}

package/dist/sandbox/core/edit/replacers.d.ts

@@ -0,0 +1,15 @@
+export type Replacer = (content: string, find: string) => Generator<string, void, unknown>;
+export declare const SimpleReplacer: Replacer;
+export declare const LineTrimmedReplacer: Replacer;
+export declare const BlockAnchorReplacer: Replacer;
+export declare const WhitespaceNormalizedReplacer: Replacer;
+export declare const IndentationFlexibleReplacer: Replacer;
+export declare const EscapeNormalizedReplacer: Replacer;
+export declare const TrimmedBoundaryReplacer: Replacer;
+export declare const ContextAwareReplacer: Replacer;
+export declare const MultiOccurrenceReplacer: Replacer;
+export declare const REPLACERS: Replacer[];
+export declare function replaceWithFallbacks(content: string, oldString: string, newString: string, replaceAll?: boolean): {
+    content: string;
+    search: string;
+};

package/dist/sandbox/core/edit/replacers.js

@@ -0,0 +1,241 @@
+function blockAt(lines, start, length) {
+    return lines.slice(start, start + length).join('\n');
+}
+function lineOffset(lines, start) {
+    let offset = 0;
+    for (let i = 0; i < start; i++)
+        offset += lines[i].length + 1;
+    return offset;
+}
+function sliceByLines(content, lines, start, length) {
+    const startOffset = lineOffset(lines, start);
+    let endOffset = startOffset;
+    for (let i = 0; i < length; i++) {
+        endOffset += lines[start + i].length;
+        if (i < length - 1)
+            endOffset += 1;
+    }
+    return content.slice(startOffset, endOffset);
+}
+function trimTrailingEmpty(lines) {
+    return lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines;
+}
+function normalizeWhitespace(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function stripCommonIndent(value) {
+    const lines = value.split('\n');
+    const nonEmpty = lines.filter((line) => line.trim());
+    if (!nonEmpty.length)
+        return value;
+    const minIndent = Math.min(...nonEmpty.map((line) => line.match(/^\s*/)?.[0].length ?? 0));
+    return lines.map((line) => (line.trim() ? line.slice(minIndent) : line)).join('\n');
+}
+function unescapeString(value) {
+    return value.replace(/\\(n|t|r|'|"|`|\\|\$)/g, (match, token) => {
+        switch (token) {
+            case 'n':
+                return '\n';
+            case 't':
+                return '\t';
+            case 'r':
+                return '\r';
+            case "'":
+                return "'";
+            case '"':
+                return '"';
+            case '`':
+                return '`';
+            case '\\':
+                return '\\';
+            case '$':
+                return '$';
+            default:
+                return match;
+        }
+    });
+}
+function levenshtein(a, b) {
+    if (!a || !b)
+        return Math.max(a.length, b.length);
+    const previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    const current = Array(b.length + 1).fill(0);
+    for (let i = 1; i <= a.length; i++) {
+        current[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
+        }
+        for (let j = 0; j <= b.length; j++)
+            previous[j] = current[j];
+    }
+    return previous[b.length];
+}
+function similarity(a, b) {
+    const maxLen = Math.max(a.length, b.length);
+    if (maxLen === 0)
+        return 1;
+    return 1 - levenshtein(a, b) / maxLen;
+}
+export const SimpleReplacer = function* (_content, find) {
+    yield find;
+};
+export const LineTrimmedReplacer = function* (content, find) {
+    const contentLines = content.split('\n');
+    const findLines = trimTrailingEmpty(find.split('\n'));
+    if (!findLines.length)
+        return;
+    for (let i = 0; i <= contentLines.length - findLines.length; i++) {
+        if (findLines.every((line, index) => contentLines[i + index].trim() === line.trim())) {
+            yield sliceByLines(content, contentLines, i, findLines.length);
+        }
+    }
+};
+export const BlockAnchorReplacer = function* (content, find) {
+    const contentLines = content.split('\n');
+    const findLines = trimTrailingEmpty(find.split('\n'));
+    if (findLines.length < 3)
+        return;
+    const first = findLines[0].trim();
+    const last = findLines[findLines.length - 1].trim();
+    let best;
+    for (let i = 0; i < contentLines.length; i++) {
+        if (contentLines[i].trim() !== first)
+            continue;
+        for (let j = i + 2; j < contentLines.length; j++) {
+            if (contentLines[j].trim() !== last)
+                continue;
+            const length = j - i + 1;
+            const block = blockAt(contentLines, i, length);
+            const score = similarity(normalizeWhitespace(block), normalizeWhitespace(findLines.join('\n')));
+            if (!best || score > best.score)
+                best = { score, start: i, length };
+            break;
+        }
+    }
+    if (best && best.score >= 0.3)
+        yield sliceByLines(content, contentLines, best.start, best.length);
+};
+export const WhitespaceNormalizedReplacer = function* (content, find) {
+    const normalizedFind = normalizeWhitespace(find);
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (normalizeWhitespace(line) === normalizedFind)
+            yield line;
+    }
+    const findLines = trimTrailingEmpty(find.split('\n'));
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+        const block = blockAt(lines, i, findLines.length);
+        if (normalizeWhitespace(block) === normalizedFind)
+            yield block;
+    }
+};
+export const IndentationFlexibleReplacer = function* (content, find) {
+    const normalizedFind = stripCommonIndent(find);
+    const lines = content.split('\n');
+    const findLines = trimTrailingEmpty(find.split('\n'));
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+        const block = blockAt(lines, i, findLines.length);
+        if (stripCommonIndent(block) === normalizedFind)
+            yield block;
+    }
+};
+export const EscapeNormalizedReplacer = function* (content, find) {
+    const unescapedFind = unescapeString(find);
+    if (content.includes(unescapedFind))
+        yield unescapedFind;
+    const lines = content.split('\n');
+    const findLines = trimTrailingEmpty(unescapedFind.split('\n'));
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+        const block = blockAt(lines, i, findLines.length);
+        if (unescapeString(block) === unescapedFind)
+            yield block;
+    }
+};
+export const TrimmedBoundaryReplacer = function* (content, find) {
+    const trimmed = find.trim();
+    if (trimmed === find)
+        return;
+    if (content.includes(trimmed))
+        yield trimmed;
+    const lines = content.split('\n');
+    const findLines = trimTrailingEmpty(find.split('\n'));
+    for (let i = 0; i <= lines.length - findLines.length; i++) {
+        const block = blockAt(lines, i, findLines.length);
+        if (block.trim() === trimmed)
+            yield block;
+    }
+};
+export const ContextAwareReplacer = function* (content, find) {
+    const lines = content.split('\n');
+    const findLines = trimTrailingEmpty(find.split('\n'));
+    if (findLines.length < 3)
+        return;
+    const first = findLines[0].trim();
+    const last = findLines[findLines.length - 1].trim();
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() !== first)
+            continue;
+        for (let j = i + 2; j < lines.length; j++) {
+            if (lines[j].trim() !== last)
+                continue;
+            const length = j - i + 1;
+            if (length !== findLines.length)
+                break;
+            let total = 0;
+            let matched = 0;
+            for (let k = 1; k < length - 1; k++) {
+                const actual = lines[i + k].trim();
+                const expected = findLines[k].trim();
+                if (actual || expected) {
+                    total++;
+                    if (actual === expected)
+                        matched++;
+                }
+            }
+            if (total === 0 || matched / total >= 0.5)
+                yield sliceByLines(content, lines, i, length);
+            break;
+        }
+    }
+};
+export const MultiOccurrenceReplacer = function* (_content, find) {
+    yield find;
+};
+export const REPLACERS = [
+    SimpleReplacer,
+    LineTrimmedReplacer,
+    BlockAnchorReplacer,
+    WhitespaceNormalizedReplacer,
+    IndentationFlexibleReplacer,
+    EscapeNormalizedReplacer,
+    TrimmedBoundaryReplacer,
+    ContextAwareReplacer,
+    MultiOccurrenceReplacer,
+];
+export function replaceWithFallbacks(content, oldString, newString, replaceAll = false) {
+    if (oldString === newString)
+        throw new Error('No changes to apply: oldString and newString are identical.');
+    let foundAny = false;
+    const tried = new Set();
+    for (const replacer of REPLACERS) {
+        for (const search of replacer(content, oldString)) {
+            if (!search || tried.has(search))
+                continue;
+            tried.add(search);
+            const index = content.indexOf(search);
+            if (index === -1)
+                continue;
+            foundAny = true;
+            if (replaceAll)
+                return { content: content.split(search).join(newString), search };
+            if (index !== content.lastIndexOf(search))
+                continue;
+            return { content: content.slice(0, index) + newString + content.slice(index + search.length), search };
+        }
+    }
+    if (!foundAny) {
+        throw new Error('Could not find oldString in the file. It must match exactly, including whitespace, indentation, and line endings.');
+    }
+    throw new Error('Found multiple matches for oldString. Provide more surrounding context to make the match unique.');
+}

package/dist/sandbox/core/logger.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { LogLevel } from './types.js';
+export declare function setLogFilePath(path: string): void;
+declare class Logger {
+    private get logFile();
+    log(message: string, level?: LogLevel): void;
+    info(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+}
+export declare const logger: Logger;
+export {};

package/dist/sandbox/core/logger.js

@@ -0,0 +1,59 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Logger class for handling plugin logging
+ */
+import { appendFileSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+import { LOG_LEVEL_INFO, LOG_LEVEL_ERROR, LOG_LEVEL_WARN } from './types.js';
+let logFilePath;
+export function setLogFilePath(path) {
+    logFilePath = path;
+}
+class Logger {
+    get logFile() {
+        if (!logFilePath)
+            throw new Error('Logger file path not set. Call setLogFilePath(path) before use.');
+        return logFilePath;
+    }
+    log(message, level = LOG_LEVEL_INFO) {
+        // Ensure log directory exists
+        try {
+            mkdirSync(dirname(this.logFile), { recursive: true });
+        }
+        catch {
+            // Directory may already exist, ignore
+        }
+        // Trim log file if it exceeds 3MB (keep last 1MB)
+        try {
+            const stats = statSync(this.logFile);
+            const maxSize = 3 * 1024 * 1024;
+            const keepSize = 1024 * 1024;
+            if (stats.size > maxSize) {
+                const content = readFileSync(this.logFile, 'utf8');
+                const trimmed = content.slice(-keepSize);
+                // Drop partial first line so we don't start mid-log
+                const firstNewline = trimmed.indexOf('\n');
+                writeFileSync(this.logFile, firstNewline >= 0 ? trimmed.slice(firstNewline + 1) : trimmed);
+            }
+        }
+        catch {
+            // File may not exist yet, ignore
+        }
+        const timestamp = new Date().toISOString();
+        const logEntry = `[${timestamp}] [${level}] ${message}\n`;
+        appendFileSync(this.logFile, logEntry);
+    }
+    info(message) {
+        this.log(message, LOG_LEVEL_INFO);
+    }
+    error(message) {
+        this.log(message, LOG_LEVEL_ERROR);
+    }
+    warn(message) {
+        this.log(message, LOG_LEVEL_WARN);
+    }
+}
+export const logger = new Logger();

package/dist/sandbox/core/lsp/client.d.ts

@@ -0,0 +1,63 @@
+import type { Diagnostic, Location, LocationLink, Position } from 'vscode-languageserver-types';
+import { type HostLspCommand } from './language.js';
+type DiagnosticMode = 'document' | 'full';
+type LocationRequest = {
+    filePath: string;
+    position: Position;
+};
+export declare class HostLspClient {
+    readonly serverID: string;
+    readonly root: string;
+    private readonly process;
+    private readonly connection;
+    private readonly initialization?;
+    private readonly documents;
+    private readonly pushDiagnostics;
+    private readonly pullDiagnostics;
+    private readonly published;
+    private readonly diagnosticRegistrations;
+    private readonly registrationListeners;
+    private readonly diagnosticListeners;
+    private capabilities?;
+    private closed;
+    private constructor();
+    static create(input: {
+        serverID: string;
+        root: string;
+        command: HostLspCommand;
+    }): Promise<HostLspClient>;
+    get diagnostics(): Map<string, Diagnostic[]>;
+    touchFile(filePath: string, diagnostics?: DiagnosticMode): Promise<number>;
+    closeFile(filePath: string): Promise<void>;
+    hover(input: LocationRequest): Promise<unknown>;
+    definition(input: LocationRequest): Promise<Location | Location[] | LocationLink[]>;
+    references(input: LocationRequest): Promise<Location[]>;
+    implementation(input: LocationRequest): Promise<Location | Location[] | LocationLink[]>;
+    prepareCallHierarchy(input: LocationRequest): Promise<unknown[]>;
+    incomingCalls(item: unknown): Promise<unknown[]>;
+    outgoingCalls(item: unknown): Promise<unknown[]>;
+    documentSymbol(filePath: string): Promise<unknown>;
+    workspaceSymbol(query: string): Promise<unknown>;
+    status(): Promise<{
+        id: string;
+        root: string;
+        status: string;
+        openFiles: number;
+    }>;
+    shutdown(): Promise<void>;
+    private registerHandlers;
+    private initialize;
+    private openOrChange;
+    private waitForDiagnostics;
+    private requestDiagnosticReport;
+    private requestWorkspaceDiagnosticReport;
+    private requestDocumentDiagnostics;
+    private requestFullDiagnostics;
+    private mergeDiagnosticResults;
+    private documentDiagnosticIdentifiers;
+    private workspaceDiagnosticIdentifiers;
+    private waitForFreshPush;
+    private waitForRegistrationChange;
+    private emitRegistrationChange;
+}
+export {};