@uncensoredcode/openbridge 0.1.0

package/packages/runtime/dist/tools/index.d.ts

@@ -0,0 +1,39 @@
+export declare const toolsModule: {
+    createBashTool: (options: {
+        runtimeRoot: string;
+    }) => import("../index.ts").RuntimeTool;
+    createEditTool: (options: {
+        runtimeRoot: string;
+    }) => import("../index.ts").RuntimeTool;
+    createListDirTool: (options: {
+        workspaceRoot: string;
+    }) => import("../index.ts").RuntimeTool;
+    createReadTool: (options: {
+        runtimeRoot: string;
+    }) => import("../index.ts").RuntimeTool;
+    createDefaultRuntimeTools: (runtimeRoot: string) => import("../index.ts").RuntimeTool[];
+    createRuntimeTools: (input: {
+        profile?: import("./registry.ts").RuntimeToolProfile;
+        runtimeRoot: string;
+        workspaceRoot?: string;
+    }) => import("../index.ts").RuntimeTool[];
+    createSecondaryRuntimeTools: (workspaceRoot: string) => import("../index.ts").RuntimeTool[];
+    createSearchFilesTool: (options: {
+        workspaceRoot: string;
+    }) => import("../index.ts").RuntimeTool;
+    MAX_FILE_READ_BYTES: number;
+    MAX_FILE_WRITE_BYTES: number;
+    ensureRuntimeRoot: (runtimeRoot: string) => Promise<string>;
+    resolveRuntimePath: (runtimeRoot: string, requestedPath: string) => Promise<string>;
+    ensureWorkspaceRoot: (workspaceRoot: string) => Promise<string>;
+    resolveWorkspacePath: (input: {
+        workspaceRoot: string;
+        requestedPath: string;
+        kind: "read" | "write";
+    }) => Promise<import("./workspace-path.ts").ResolvedWorkspacePath>;
+    createWriteTool: (options: {
+        runtimeRoot: string;
+    }) => import("../index.ts").RuntimeTool;
+};
+export type { RuntimeToolProfile } from "./registry.ts";
+export type { ResolvedWorkspacePath } from "./workspace-path.ts";

package/packages/runtime/dist/tools/index.js

@@ -0,0 +1,27 @@
+import { bashModule } from "./bash.js";
+import { editModule } from "./edit.js";
+import { listDirModule } from "./list-dir.js";
+import { readModule } from "./read.js";
+import { registryModule } from "./registry.js";
+import { runtimePathModule } from "./runtime-path.js";
+import { searchFilesModule } from "./search-files.js";
+import { textFileModule } from "./text-file.js";
+import { workspacePathModule } from "./workspace-path.js";
+import { writeModule } from "./write.js";
+export const toolsModule = {
+    createBashTool: bashModule.createBashTool,
+    createEditTool: editModule.createEditTool,
+    createListDirTool: listDirModule.createListDirTool,
+    createReadTool: readModule.createReadTool,
+    createDefaultRuntimeTools: registryModule.createDefaultRuntimeTools,
+    createRuntimeTools: registryModule.createRuntimeTools,
+    createSecondaryRuntimeTools: registryModule.createSecondaryRuntimeTools,
+    createSearchFilesTool: searchFilesModule.createSearchFilesTool,
+    MAX_FILE_READ_BYTES: textFileModule.MAX_FILE_READ_BYTES,
+    MAX_FILE_WRITE_BYTES: textFileModule.MAX_FILE_WRITE_BYTES,
+    ensureRuntimeRoot: runtimePathModule.ensureRuntimeRoot,
+    resolveRuntimePath: runtimePathModule.resolveRuntimePath,
+    ensureWorkspaceRoot: workspacePathModule.ensureWorkspaceRoot,
+    resolveWorkspacePath: workspacePathModule.resolveWorkspacePath,
+    createWriteTool: writeModule.createWriteTool
+};

package/packages/runtime/dist/tools/list-dir.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeTool } from "../execution/types.ts";
+type ListDirToolOptions = {
+    workspaceRoot: string;
+};
+declare function createListDirTool(options: ListDirToolOptions): RuntimeTool;
+export declare const listDirModule: {
+    createListDirTool: typeof createListDirTool;
+};
+export {};

package/packages/runtime/dist/tools/list-dir.js

@@ -0,0 +1,127 @@
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+import { executionTypesModule } from "../execution/types.js";
+import { textFileModule } from "./text-file.js";
+import { workspacePathModule } from "./workspace-path.js";
+const { ToolExecutionError } = executionTypesModule;
+const { MAX_LIST_DIR_ENTRIES } = textFileModule;
+const { resolveWorkspacePath } = workspacePathModule;
+function createListDirTool(options) {
+    return {
+        definition: {
+            name: "list_dir",
+            description: "List one workspace directory without recursion. Returns compact metadata for each entry.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    include_hidden: {
+                        type: "boolean",
+                        description: "Include dotfiles and dot-directories when true. Defaults to false."
+                    },
+                    path: {
+                        type: "string",
+                        description: "Workspace-relative directory path to inspect. Defaults to the workspace root."
+                    }
+                },
+                required: []
+            }
+        },
+        async execute(args) {
+            const target = await resolveWorkspacePath({
+                workspaceRoot: options.workspaceRoot,
+                requestedPath: optionalString(args, "path") ?? ".",
+                kind: "read"
+            });
+            const includeHidden = optionalBoolean(args, "include_hidden", false);
+            try {
+                const entries = await readdir(target.absolutePath, { withFileTypes: true });
+                const visibleEntries = entries
+                    .filter((entry) => includeHidden || !entry.name.startsWith("."))
+                    .sort(compareDirectoryEntries);
+                const limitedEntries = visibleEntries.slice(0, MAX_LIST_DIR_ENTRIES);
+                const results = await Promise.all(limitedEntries.map(async (entry) => {
+                    const entryPath = path.join(target.absolutePath, entry.name);
+                    const stats = await lstat(entryPath);
+                    return {
+                        name: entry.name,
+                        relative_path: path.relative(target.workspaceRoot, entryPath) || ".",
+                        type: getEntryType(stats),
+                        size: stats.size
+                    };
+                }));
+                return {
+                    path: target.relativePath,
+                    truncated: visibleEntries.length > MAX_LIST_DIR_ENTRIES,
+                    entries: results
+                };
+            }
+            catch (error) {
+                if (error.code === "ENOTDIR") {
+                    throw new ToolExecutionError("invalid_type", `Path "${target.relativePath}" is not a directory.`);
+                }
+                if (error.code === "ENOENT") {
+                    throw new ToolExecutionError("not_found", `Directory does not exist: ${target.relativePath}`);
+                }
+                throw new ToolExecutionError("io_error", `Unable to list directory "${target.relativePath}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    };
+}
+function compareDirectoryEntries(left, right) {
+    if (left.isDirectory() !== right.isDirectory()) {
+        return left.isDirectory() ? -1 : 1;
+    }
+    return compareNames(left.name, right.name);
+}
+function compareNames(left, right) {
+    const leftKey = left.toLowerCase();
+    const rightKey = right.toLowerCase();
+    if (leftKey < rightKey) {
+        return -1;
+    }
+    if (leftKey > rightKey) {
+        return 1;
+    }
+    if (left < right) {
+        return -1;
+    }
+    if (left > right) {
+        return 1;
+    }
+    return 0;
+}
+function getEntryType(stats) {
+    if (stats.isSymbolicLink()) {
+        return "symlink";
+    }
+    if (stats.isDirectory()) {
+        return "dir";
+    }
+    if (stats.isFile()) {
+        return "file";
+    }
+    return "other";
+}
+function optionalString(args, key) {
+    const value = args[key];
+    if (value === undefined) {
+        return null;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    throw new ToolExecutionError("invalid_arguments", `${key} must be a string.`);
+}
+function optionalBoolean(args, key, fallback) {
+    const value = args[key];
+    if (value === undefined) {
+        return fallback;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    throw new ToolExecutionError("invalid_arguments", `${key} must be a boolean.`);
+}
+export const listDirModule = {
+    createListDirTool
+};

package/packages/runtime/dist/tools/read.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeTool } from "../execution/types.ts";
+type ReadToolOptions = {
+    runtimeRoot: string;
+};
+declare function createReadTool(options: ReadToolOptions): RuntimeTool;
+export declare const readModule: {
+    createReadTool: typeof createReadTool;
+};
+export {};

package/packages/runtime/dist/tools/read.js

@@ -0,0 +1,56 @@
+import { executionTypesModule } from "../execution/types.js";
+import { runtimePathModule } from "./runtime-path.js";
+import { textFileModule } from "./text-file.js";
+const { ToolExecutionError } = executionTypesModule;
+const { MAX_FILE_READ_BYTES, readTextFileWithinLimit } = textFileModule;
+const { resolveRuntimePath } = runtimePathModule;
+function createReadTool(options) {
+    return {
+        definition: {
+            name: "read",
+            description: "Read a UTF-8 text file from the local filesystem.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Absolute path or path relative to the runtime root."
+                    }
+                },
+                required: ["path"]
+            }
+        },
+        async execute(args) {
+            const resolvedPath = await resolveRuntimePath(options.runtimeRoot, requireString(args, "path"));
+            try {
+                const { content, bytes } = await readTextFileWithinLimit({
+                    absolutePath: resolvedPath,
+                    relativePath: resolvedPath,
+                    maxBytes: MAX_FILE_READ_BYTES,
+                    operation: "read"
+                });
+                return {
+                    path: resolvedPath,
+                    bytes,
+                    content
+                };
+            }
+            catch (error) {
+                if (error instanceof ToolExecutionError) {
+                    throw error;
+                }
+                throw new ToolExecutionError("io_error", `Unable to read file "${resolvedPath}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    };
+}
+function requireString(args, key) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) {
+        return value;
+    }
+    throw new ToolExecutionError("invalid_arguments", `${key} must be a non-empty string.`);
+}
+export const readModule = {
+    createReadTool
+};

package/packages/runtime/dist/tools/registry.d.ts

@@ -0,0 +1,15 @@
+import type { RuntimeTool } from "../execution/types.ts";
+type RuntimeToolProfile = "default" | "workspace";
+declare function createDefaultRuntimeTools(runtimeRoot: string): RuntimeTool[];
+declare function createSecondaryRuntimeTools(workspaceRoot: string): RuntimeTool[];
+declare function createRuntimeTools(input: {
+    profile?: RuntimeToolProfile;
+    runtimeRoot: string;
+    workspaceRoot?: string;
+}): RuntimeTool[];
+export declare const registryModule: {
+    createDefaultRuntimeTools: typeof createDefaultRuntimeTools;
+    createSecondaryRuntimeTools: typeof createSecondaryRuntimeTools;
+    createRuntimeTools: typeof createRuntimeTools;
+};
+export type { RuntimeToolProfile };

package/packages/runtime/dist/tools/registry.js

@@ -0,0 +1,38 @@
+import { bashModule } from "./bash.js";
+import { editModule } from "./edit.js";
+import { listDirModule } from "./list-dir.js";
+import { readModule } from "./read.js";
+import { searchFilesModule } from "./search-files.js";
+import { writeModule } from "./write.js";
+const { createBashTool } = bashModule;
+const { createEditTool } = editModule;
+const { createListDirTool } = listDirModule;
+const { createReadTool } = readModule;
+const { createSearchFilesTool } = searchFilesModule;
+const { createWriteTool } = writeModule;
+function createDefaultRuntimeTools(runtimeRoot) {
+    return [
+        createReadTool({ runtimeRoot }),
+        createWriteTool({ runtimeRoot }),
+        createEditTool({ runtimeRoot }),
+        createBashTool({ runtimeRoot })
+    ];
+}
+function createSecondaryRuntimeTools(workspaceRoot) {
+    return [createListDirTool({ workspaceRoot }), createSearchFilesTool({ workspaceRoot })];
+}
+function createRuntimeTools(input) {
+    const defaultTools = createDefaultRuntimeTools(input.runtimeRoot);
+    if ((input.profile ?? "default") !== "workspace") {
+        return defaultTools;
+    }
+    return [
+        ...defaultTools,
+        ...createSecondaryRuntimeTools(input.workspaceRoot ?? input.runtimeRoot)
+    ];
+}
+export const registryModule = {
+    createDefaultRuntimeTools,
+    createSecondaryRuntimeTools,
+    createRuntimeTools
+};

package/packages/runtime/dist/tools/runtime-path.d.ts

@@ -0,0 +1,7 @@
+declare function ensureRuntimeRoot(runtimeRoot: string): Promise<string>;
+declare function resolveRuntimePath(runtimeRoot: string, requestedPath: string): Promise<string>;
+export declare const runtimePathModule: {
+    ensureRuntimeRoot: typeof ensureRuntimeRoot;
+    resolveRuntimePath: typeof resolveRuntimePath;
+};
+export {};

package/packages/runtime/dist/tools/runtime-path.js

@@ -0,0 +1,22 @@
+import { mkdir, realpath } from "node:fs/promises";
+import path from "node:path";
+import { executionTypesModule } from "../execution/types.js";
+const { ToolExecutionError } = executionTypesModule;
+async function ensureRuntimeRoot(runtimeRoot) {
+    await mkdir(runtimeRoot, { recursive: true });
+    return realpath(runtimeRoot);
+}
+async function resolveRuntimePath(runtimeRoot, requestedPath) {
+    const normalizedPath = requestedPath.trim();
+    if (!normalizedPath) {
+        throw new ToolExecutionError("invalid_arguments", "path must be a non-empty string.");
+    }
+    const basePath = await ensureRuntimeRoot(runtimeRoot);
+    return path.isAbsolute(normalizedPath)
+        ? path.resolve(normalizedPath)
+        : path.resolve(basePath, normalizedPath);
+}
+export const runtimePathModule = {
+    ensureRuntimeRoot,
+    resolveRuntimePath
+};

package/packages/runtime/dist/tools/search-files.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeTool } from "../execution/types.ts";
+type SearchFilesToolOptions = {
+    workspaceRoot: string;
+};
+declare function createSearchFilesTool(options: SearchFilesToolOptions): RuntimeTool;
+export declare const searchFilesModule: {
+    createSearchFilesTool: typeof createSearchFilesTool;
+};
+export {};

package/packages/runtime/dist/tools/search-files.js

@@ -0,0 +1,149 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { executionTypesModule } from "../execution/types.js";
+import { textFileModule } from "./text-file.js";
+import { workspacePathModule } from "./workspace-path.js";
+const { ToolExecutionError } = executionTypesModule;
+const { MAX_SEARCH_FILE_BYTES, MAX_SEARCH_RESULTS, readTextFileWithinLimit, truncateSnippet } = textFileModule;
+const { ensureWorkspaceRoot } = workspacePathModule;
+const IGNORED_DIRECTORY_NAMES = new Set([
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    "coverage"
+]);
+function createSearchFilesTool(options) {
+    return {
+        definition: {
+            name: "search_files",
+            description: "Search UTF-8 text files in the workspace for a literal query string.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Literal text to search for across workspace files."
+                    }
+                },
+                required: ["query"]
+            }
+        },
+        async execute(args) {
+            const query = requireQuery(args);
+            const workspaceRoot = await ensureWorkspaceRoot(options.workspaceRoot);
+            const results = [];
+            let truncated = false;
+            await walkWorkspace(workspaceRoot, workspaceRoot, query, results, () => {
+                truncated = true;
+            });
+            return {
+                query,
+                truncated,
+                results
+            };
+        }
+    };
+}
+async function walkWorkspace(workspaceRoot, currentDirectory, query, results, onLimitReached) {
+    const entries = (await readdir(currentDirectory, { withFileTypes: true })).sort(compareEntries);
+    for (const entry of entries) {
+        if (entry.isSymbolicLink()) {
+            continue;
+        }
+        const entryPath = path.join(currentDirectory, entry.name);
+        const relativePath = path.relative(workspaceRoot, entryPath) || ".";
+        if (entry.isDirectory()) {
+            if (IGNORED_DIRECTORY_NAMES.has(entry.name)) {
+                continue;
+            }
+            await walkWorkspace(workspaceRoot, entryPath, query, results, onLimitReached);
+            if (results.length >= MAX_SEARCH_RESULTS) {
+                onLimitReached();
+                return;
+            }
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        const matches = await searchFile(relativePath, entryPath, query);
+        for (const match of matches) {
+            results.push(match);
+            if (results.length >= MAX_SEARCH_RESULTS) {
+                onLimitReached();
+                return;
+            }
+        }
+    }
+}
+async function searchFile(relativePath, absolutePath, query) {
+    try {
+        const { content } = await readTextFileWithinLimit({
+            absolutePath,
+            relativePath,
+            maxBytes: MAX_SEARCH_FILE_BYTES,
+            operation: "search"
+        });
+        const lines = content.split(/\r?\n/u);
+        const matches = [];
+        for (let index = 0; index < lines.length; index += 1) {
+            if (!lines[index]?.includes(query)) {
+                continue;
+            }
+            matches.push({
+                relative_path: relativePath,
+                line_number: index + 1,
+                snippet: truncateSnippet(lines[index] ?? "")
+            });
+        }
+        return matches;
+    }
+    catch (error) {
+        if (error instanceof ToolExecutionError &&
+            (error.code === "binary_file" ||
+                error.code === "file_too_large" ||
+                error.code === "invalid_type")) {
+            return [];
+        }
+        throw error;
+    }
+}
+function compareEntries(left, right) {
+    if (left.isDirectory() !== right.isDirectory()) {
+        return left.isDirectory() ? -1 : 1;
+    }
+    return compareNames(left.name, right.name);
+}
+function compareNames(left, right) {
+    const leftKey = left.toLowerCase();
+    const rightKey = right.toLowerCase();
+    if (leftKey < rightKey) {
+        return -1;
+    }
+    if (leftKey > rightKey) {
+        return 1;
+    }
+    if (left < right) {
+        return -1;
+    }
+    if (left > right) {
+        return 1;
+    }
+    return 0;
+}
+function requireQuery(args) {
+    const value = args.query;
+    if (typeof value !== "string") {
+        throw new ToolExecutionError("invalid_arguments", "query must be a string.");
+    }
+    const query = value.trim();
+    if (!query) {
+        throw new ToolExecutionError("invalid_arguments", "query must be a non-empty string.");
+    }
+    return query;
+}
+export const searchFilesModule = {
+    createSearchFilesTool
+};

package/packages/runtime/dist/tools/text-file.d.ts

@@ -0,0 +1,32 @@
+type ReadTextFileWithinLimitInput = {
+    absolutePath: string;
+    relativePath: string;
+    maxBytes: number;
+    operation: "read" | "search" | "write";
+};
+declare function readTextFileWithinLimit(input: ReadTextFileWithinLimitInput): Promise<{
+    content: string;
+    bytes: number;
+}>;
+declare function assertWritableTextTarget(input: {
+    absolutePath: string;
+    relativePath: string;
+    maxBytes: number;
+}): Promise<void>;
+declare function assertTextContent(content: string, relativePath: string, maxBytes: number): number;
+declare function writeTextFileAtomic(absolutePath: string, content: string): Promise<void>;
+declare function truncateSnippet(line: string, maxChars?: number): string;
+export declare const textFileModule: {
+    MAX_FILE_READ_BYTES: number;
+    MAX_FILE_WRITE_BYTES: number;
+    MAX_LIST_DIR_ENTRIES: number;
+    MAX_SEARCH_FILE_BYTES: number;
+    MAX_SEARCH_RESULTS: number;
+    MAX_SEARCH_SNIPPET_CHARS: number;
+    readTextFileWithinLimit: typeof readTextFileWithinLimit;
+    assertWritableTextTarget: typeof assertWritableTextTarget;
+    assertTextContent: typeof assertTextContent;
+    writeTextFileAtomic: typeof writeTextFileAtomic;
+    truncateSnippet: typeof truncateSnippet;
+};
+export {};

package/packages/runtime/dist/tools/text-file.js

@@ -0,0 +1,101 @@
+import { readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { executionTypesModule } from "../execution/types.js";
+const { ToolExecutionError } = executionTypesModule;
+const MAX_FILE_READ_BYTES = 64 * 1024;
+const MAX_FILE_WRITE_BYTES = 64 * 1024;
+const MAX_LIST_DIR_ENTRIES = 200;
+const MAX_SEARCH_FILE_BYTES = 256 * 1024;
+const MAX_SEARCH_RESULTS = 50;
+const MAX_SEARCH_SNIPPET_CHARS = 240;
+const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+async function readTextFileWithinLimit(input) {
+    const details = await statExistingPath(input.absolutePath, input.relativePath);
+    if (!details.isFile()) {
+        throw new ToolExecutionError("invalid_type", `Path "${input.relativePath}" is not a file.`);
+    }
+    if (details.size > input.maxBytes) {
+        throw new ToolExecutionError("file_too_large", `File "${input.relativePath}" is ${details.size} bytes, which exceeds the ${input.maxBytes}-byte limit for ${input.operation}.`);
+    }
+    const buffer = await readFile(input.absolutePath);
+    const content = decodeTextBuffer(buffer, input.relativePath);
+    return {
+        content,
+        bytes: buffer.byteLength
+    };
+}
+async function assertWritableTextTarget(input) {
+    try {
+        await readTextFileWithinLimit({
+            absolutePath: input.absolutePath,
+            relativePath: input.relativePath,
+            maxBytes: input.maxBytes,
+            operation: "write"
+        });
+    }
+    catch (error) {
+        if (error instanceof ToolExecutionError && error.code === "not_found") {
+            return;
+        }
+        throw error;
+    }
+}
+function assertTextContent(content, relativePath, maxBytes) {
+    const bytes = Buffer.byteLength(content, "utf8");
+    if (bytes > maxBytes) {
+        throw new ToolExecutionError("file_too_large", `Content for "${relativePath}" is ${bytes} bytes, which exceeds the ${maxBytes}-byte write limit.`);
+    }
+    return bytes;
+}
+async function writeTextFileAtomic(absolutePath, content) {
+    const tempPath = `${absolutePath}.bridge-runtime-tmp-${process.pid}-${Date.now()}`;
+    try {
+        await writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
+        await rename(tempPath, absolutePath);
+    }
+    catch (error) {
+        await unlink(tempPath).catch(() => undefined);
+        throw error;
+    }
+}
+function truncateSnippet(line, maxChars = MAX_SEARCH_SNIPPET_CHARS) {
+    const trimmed = line.trim();
+    if (trimmed.length <= maxChars) {
+        return trimmed;
+    }
+    return `${trimmed.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+function decodeTextBuffer(buffer, relativePath) {
+    if (buffer.includes(0)) {
+        throw new ToolExecutionError("binary_file", `File "${relativePath}" appears to be binary.`);
+    }
+    try {
+        return UTF8_DECODER.decode(buffer);
+    }
+    catch {
+        throw new ToolExecutionError("binary_file", `File "${relativePath}" is not valid UTF-8 text.`);
+    }
+}
+async function statExistingPath(absolutePath, relativePath) {
+    try {
+        return await stat(absolutePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new ToolExecutionError("not_found", `File does not exist: ${relativePath}`);
+        }
+        throw new ToolExecutionError("io_error", `Unable to inspect "${relativePath}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export const textFileModule = {
+    MAX_FILE_READ_BYTES,
+    MAX_FILE_WRITE_BYTES,
+    MAX_LIST_DIR_ENTRIES,
+    MAX_SEARCH_FILE_BYTES,
+    MAX_SEARCH_RESULTS,
+    MAX_SEARCH_SNIPPET_CHARS,
+    readTextFileWithinLimit,
+    assertWritableTextTarget,
+    assertTextContent,
+    writeTextFileAtomic,
+    truncateSnippet
+};

package/packages/runtime/dist/tools/workspace-path.d.ts

@@ -0,0 +1,17 @@
+type ResolveWorkspacePathInput = {
+    workspaceRoot: string;
+    requestedPath: string;
+    kind: "read" | "write";
+};
+type ResolvedWorkspacePath = {
+    absolutePath: string;
+    relativePath: string;
+    workspaceRoot: string;
+};
+declare function ensureWorkspaceRoot(workspaceRoot: string): Promise<string>;
+declare function resolveWorkspacePath(input: ResolveWorkspacePathInput): Promise<ResolvedWorkspacePath>;
+export declare const workspacePathModule: {
+    ensureWorkspaceRoot: typeof ensureWorkspaceRoot;
+    resolveWorkspacePath: typeof resolveWorkspacePath;
+};
+export type { ResolvedWorkspacePath };