@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.74

package/dist/template/loader/DocumentLoader.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * DocumentLoader — loads documents from crewx.yaml `documents:` section.
+ *
+ * Supports:
+ *   - Inline string:       `notice: "Some text"`
+ *   - Inline object:       `notice: { content: "Some text" }`
+ *   - File path (relative):  `guide: { path: "docs/guide.md" }`
+ *   - File path (absolute):  `guide: { path: "/abs/docs/guide.md" }`
+ *
+ * File I/O is delegated to IFsAdapter for testability and future WEB compat.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentLoader = void 0;
+const NodeFsAdapter_1 = require("../../platform/NodeFsAdapter");
+// ── DocumentLoader ──────────────────────────────────────────────────────────
+class DocumentLoader {
+    docs = new Map();
+    fs;
+    constructor(fsAdapter) {
+        this.fs = fsAdapter ?? NodeFsAdapter_1.defaultFsAdapter;
+    }
+    /**
+     * Load all documents from the `documents:` section of crewx.yaml.
+     *
+     * @param sources     - Record of document name → source (string, {path}, or {content})
+     * @param projectRoot - Base directory for resolving relative file paths
+     */
+    async load(sources, projectRoot) {
+        if (!sources)
+            return;
+        for (const [name, rawSource] of Object.entries(sources)) {
+            const source = rawSource;
+            if (typeof source === 'string') {
+                // Case 1: inline string
+                this.docs.set(name, { content: source });
+            }
+            else if (source && typeof source === 'object') {
+                const src = source;
+                if ('content' in src && typeof src['content'] === 'string') {
+                    // Case 2: inline object with content field
+                    this.docs.set(name, { content: src['content'] });
+                }
+                else if ('path' in src && typeof src['path'] === 'string') {
+                    // Case 3: file path
+                    await this.loadFromFile(name, src['path'], projectRoot);
+                }
+                else {
+                    console.warn(`[DocumentLoader] Skipping '${name}': unsupported format`);
+                }
+            }
+            else {
+                console.warn(`[DocumentLoader] Skipping '${name}': unsupported format`);
+            }
+        }
+    }
+    /** Get document text content by name. Returns undefined if not loaded. */
+    async getContent(name) {
+        return this.docs.get(name)?.content;
+    }
+    /**
+     * Get a simple TOC (table of contents) for a markdown document.
+     * Extracts headings (lines starting with `#`) and returns them as an indented list.
+     * Returns undefined if there are no headings.
+     */
+    async getToc(name) {
+        const doc = this.docs.get(name);
+        if (!doc)
+            return undefined;
+        const headings = [];
+        for (const line of doc.content.split('\n')) {
+            const match = /^(#{1,6})\s+(.+)$/.exec(line.trim());
+            if (match) {
+                headings.push({ depth: match[1].length, text: match[2].trim() });
+            }
+        }
+        if (headings.length === 0)
+            return undefined;
+        return headings
+            .map(({ depth, text }) => `${'  '.repeat(depth - 1)}- ${text}`)
+            .join('\n');
+    }
+    /** Get the resolved absolute file path for a file-based document. */
+    getPath(name) {
+        return this.docs.get(name)?.path;
+    }
+    /** Get all loaded document names. */
+    getNames() {
+        return Array.from(this.docs.keys());
+    }
+    /**
+     * Build a documents context object suitable for Handlebars template rendering.
+     * Returns `{ docName: { content, toc, path? }, ... }`.
+     */
+    async buildContext() {
+        const ctx = {};
+        for (const name of this.docs.keys()) {
+            const content = await this.getContent(name) ?? '';
+            const toc = await this.getToc(name);
+            const path = this.getPath(name);
+            ctx[name] = { content, toc, ...(path ? { path } : {}) };
+        }
+        return ctx;
+    }
+    // ── Private ───────────────────────────────────────────────────────────────
+    async loadFromFile(name, filePath, projectRoot) {
+        try {
+            const resolvedPath = this.resolve(filePath, projectRoot);
+            const content = await this.fs.readFile(resolvedPath);
+            this.docs.set(name, { content, path: resolvedPath });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[DocumentLoader] Failed to load '${name}' from '${filePath}': ${msg}`);
+        }
+    }
+    resolve(filePath, projectRoot) {
+        if (this.fs.isAbsolute(filePath)) {
+            return filePath;
+        }
+        if (projectRoot) {
+            return this.fs.resolvePath(projectRoot, filePath);
+        }
+        return this.fs.resolvePath(filePath);
+    }
+}
+exports.DocumentLoader = DocumentLoader;
+//# sourceMappingURL=DocumentLoader.js.map

package/dist/template/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Type definitions for the CrewX template engine.
+ */
+/**
+ * Exec helper policy — controls which shell commands may be executed
+ * by the {{exec "..."}} Handlebars helper.
+ *
+ * Priority: deny > builtin(@crewx) > allow > reject
+ */
+export interface ExecPolicy {
+    /** Glob patterns for commands that are explicitly allowed (after deny check). */
+    allow?: string[];
+    /** Glob patterns for commands that are always denied (highest priority). */
+    deny?: string[];
+    /** Execution timeout in milliseconds (default: 5000). */
+    timeout?: number;
+}
+/**
+ * Context object passed to renderPrompt() / TemplateEngine.render().
+ *
+ * Loosely typed to support arbitrary Handlebars context keys while providing
+ * structured types for the well-known properties.
+ */
+export interface TemplateContext {
+    /** Pre-loaded documents keyed by document name. */
+    documents?: Record<string, {
+        content?: string;
+        toc?: string;
+        summary?: string;
+    }>;
+    /** Environment variables (subset). */
+    env?: Record<string, string>;
+    /** Agent metadata. */
+    agent?: Record<string, unknown>;
+    /** Current platform. */
+    platform?: string;
+    /** Execution mode. */
+    mode?: string;
+    /** Arbitrary additional context. */
+    [key: string]: unknown;
+}
+/**
+ * Options for the TemplateEngine constructor.
+ */
+export interface TemplateEngineOptions {
+    /** Exec policy. If omitted, exec helper is disabled (all commands blocked). */
+    execPolicy?: ExecPolicy;
+    /** Whether the exec helper is enabled. Default: true. Set to false for browser environments. */
+    execEnabled?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/template/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for the CrewX template engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/testing/index.d.ts

@@ -0,0 +1,12 @@
+export { createMockContext } from './mock-context';
+export type { MockContextOptions, MockContext } from './mock-context';
+export { createMockLogger } from './mock-logger';
+export type { MockLogger, LogEntry } from './mock-logger';
+export { createMockStore } from './mock-store';
+export { createMockStorage } from './mock-storage';
+export type { MockStorage } from './mock-storage';
+export { createMockAudit } from './mock-audit';
+export type { MockAudit, AuditEvent } from './mock-audit';
+export { createMockRouter } from './mock-router';
+export type { MockRouter, RegisteredRoute } from './mock-router';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockRouter = exports.createMockAudit = exports.createMockStorage = exports.createMockStore = exports.createMockLogger = exports.createMockContext = void 0;
+var mock_context_1 = require("./mock-context");
+Object.defineProperty(exports, "createMockContext", { enumerable: true, get: function () { return mock_context_1.createMockContext; } });
+var mock_logger_1 = require("./mock-logger");
+Object.defineProperty(exports, "createMockLogger", { enumerable: true, get: function () { return mock_logger_1.createMockLogger; } });
+var mock_store_1 = require("./mock-store");
+Object.defineProperty(exports, "createMockStore", { enumerable: true, get: function () { return mock_store_1.createMockStore; } });
+var mock_storage_1 = require("./mock-storage");
+Object.defineProperty(exports, "createMockStorage", { enumerable: true, get: function () { return mock_storage_1.createMockStorage; } });
+var mock_audit_1 = require("./mock-audit");
+Object.defineProperty(exports, "createMockAudit", { enumerable: true, get: function () { return mock_audit_1.createMockAudit; } });
+var mock_router_1 = require("./mock-router");
+Object.defineProperty(exports, "createMockRouter", { enumerable: true, get: function () { return mock_router_1.createMockRouter; } });
+//# sourceMappingURL=index.js.map

package/dist/testing/mock-audit.d.ts

@@ -0,0 +1,10 @@
+import type { AuditSink } from '../adapter/types';
+export interface AuditEvent {
+    event: string;
+    payload: Record<string, unknown>;
+}
+export interface MockAudit extends AuditSink {
+    events: AuditEvent[];
+}
+export declare function createMockAudit(): MockAudit;
+//# sourceMappingURL=mock-audit.d.ts.map

package/dist/testing/mock-audit.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockAudit = createMockAudit;
+function createMockAudit() {
+    const events = [];
+    return {
+        events,
+        async log(event, payload) {
+            events.push({ event, payload });
+        },
+    };
+}
+//# sourceMappingURL=mock-audit.js.map

package/dist/testing/mock-context.d.ts

@@ -0,0 +1,27 @@
+import type { AdapterCapability, AdapterContext, AgentRunner, InboundEvent, InboundMessage, OutboundMessage } from '../adapter/types';
+import { type MockAudit } from './mock-audit';
+import { type MockLogger } from './mock-logger';
+import { type MockRouter } from './mock-router';
+import { type MockStorage } from './mock-storage';
+export interface MockContextOptions<TConfig = unknown> {
+    instanceId?: string;
+    installationId?: string;
+    config: TConfig;
+    capabilities?: AdapterCapability[];
+    agentRunner?: Partial<AgentRunner>;
+    abortSignal?: AbortSignal;
+}
+export interface MockContext<TConfig = unknown> extends AdapterContext<TConfig> {
+    audit: MockAudit;
+    log: MockLogger;
+    router: MockRouter;
+    storage: MockStorage;
+    inboundCalls: InboundMessage[];
+    emittedEvents: InboundEvent[];
+    sentMessages: Array<{
+        messageId: string;
+        patch: Partial<OutboundMessage>;
+    }>;
+}
+export declare function createMockContext<TConfig = unknown>(opts: MockContextOptions<TConfig>): MockContext<TConfig>;
+//# sourceMappingURL=mock-context.d.ts.map

package/dist/testing/mock-context.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockContext = createMockContext;
+const mock_audit_1 = require("./mock-audit");
+const mock_logger_1 = require("./mock-logger");
+const mock_router_1 = require("./mock-router");
+const mock_store_1 = require("./mock-store");
+const mock_storage_1 = require("./mock-storage");
+function createMockContext(opts) {
+    const instanceId = opts.instanceId ?? 'mock-instance';
+    const audit = (0, mock_audit_1.createMockAudit)();
+    const log = (0, mock_logger_1.createMockLogger)();
+    const router = (0, mock_router_1.createMockRouter)();
+    const db = (0, mock_store_1.createMockStore)(instanceId);
+    const storage = (0, mock_storage_1.createMockStorage)();
+    const inboundCalls = [];
+    const emittedEvents = [];
+    const sentMessages = [];
+    const agentRunner = {
+        run: async () => ({ output: '' }),
+        ...opts.agentRunner,
+    };
+    const abortController = new AbortController();
+    const inbound = async (msg) => {
+        inboundCalls.push(msg);
+        return { accepted: true };
+    };
+    const emitEvent = async (event) => {
+        emittedEvents.push(event);
+        return { accepted: true };
+    };
+    const updateMessage = async (messageId, patch) => {
+        sentMessages.push({ messageId, patch });
+    };
+    const resolveUser = async (userId) => ({
+        userId,
+        displayName: userId,
+    });
+    const respondSync = async () => { };
+    const proactive = async () => ({
+        messageId: 'mock-proactive',
+        sentAt: Date.now(),
+    });
+    return {
+        instanceId,
+        installationId: opts.installationId,
+        config: opts.config,
+        capabilities: new Set(opts.capabilities ?? []),
+        log,
+        agentRunner,
+        db,
+        storage,
+        audit,
+        abortSignal: opts.abortSignal ?? abortController.signal,
+        httpRouter: router,
+        router,
+        inbound,
+        emitEvent,
+        updateMessage,
+        resolveUser,
+        respondSync,
+        proactive,
+        inboundCalls,
+        emittedEvents,
+        sentMessages,
+    };
+}
+//# sourceMappingURL=mock-context.js.map

package/dist/testing/mock-logger.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from '../adapter/types';
+export interface LogEntry {
+    msg: string;
+    meta?: Record<string, unknown>;
+}
+export interface MockLogger extends Logger {
+    entries: {
+        debug: LogEntry[];
+        info: LogEntry[];
+        warn: LogEntry[];
+        error: LogEntry[];
+    };
+}
+export declare function createMockLogger(): MockLogger;
+//# sourceMappingURL=mock-logger.d.ts.map

package/dist/testing/mock-logger.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockLogger = createMockLogger;
+function createMockLogger() {
+    const entries = {
+        debug: [],
+        info: [],
+        warn: [],
+        error: [],
+    };
+    return {
+        entries,
+        debug(msg, meta) {
+            entries.debug.push({ msg, meta });
+        },
+        info(msg, meta) {
+            entries.info.push({ msg, meta });
+        },
+        warn(msg, meta) {
+            entries.warn.push({ msg, meta });
+        },
+        error(msg, meta) {
+            entries.error.push({ msg, meta });
+        },
+    };
+}
+//# sourceMappingURL=mock-logger.js.map

package/dist/testing/mock-router.d.ts

@@ -0,0 +1,16 @@
+import type { HttpRouter, RawRequest, RawResponse, RouteOptions } from '../adapter/types';
+export interface RegisteredRoute {
+    path: string;
+    opts?: RouteOptions;
+    handler: (req: RawRequest, res: RawResponse) => Promise<void>;
+}
+export interface MockRouter extends HttpRouter {
+    routes: RegisteredRoute[];
+    simulate(method: string, path: string, body?: Buffer, headers?: Record<string, string>, params?: Record<string, string>, query?: Record<string, string>): Promise<{
+        status: number;
+        body: unknown;
+        headers: Record<string, string>;
+    }>;
+}
+export declare function createMockRouter(): MockRouter;
+//# sourceMappingURL=mock-router.d.ts.map

package/dist/testing/mock-router.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockRouter = createMockRouter;
+function createMockRawResponse() {
+    let statusCode = 200;
+    let jsonBody;
+    let sentBody;
+    const headers = {};
+    const self = {
+        status(code) {
+            statusCode = code;
+            return self;
+        },
+        set(field, value) {
+            headers[field] = value;
+            return self;
+        },
+        send(body) {
+            sentBody = body;
+            return self;
+        },
+        json(body) {
+            jsonBody = body;
+            return self;
+        },
+        end() {
+            return self;
+        },
+        getStatusCode: () => statusCode,
+        getJsonBody: () => jsonBody,
+        getSentBody: () => sentBody,
+        getHeaders: () => ({ ...headers }),
+    };
+    return self;
+}
+function createMockRouter() {
+    const routes = [];
+    const router = {
+        routes,
+        registerRoute(path, handler, opts) {
+            routes.push({ path, handler, opts });
+        },
+        async simulate(method, path, body = Buffer.alloc(0), headers = {}, params = {}, query = {}) {
+            const route = routes.find(r => r.path === path);
+            if (!route) {
+                return { status: 404, body: { error: 'Not found' }, headers: {} };
+            }
+            const req = {
+                method,
+                url: path,
+                headers,
+                body,
+                params,
+                query,
+            };
+            const res = createMockRawResponse();
+            await route.handler(req, res);
+            return {
+                status: res.getStatusCode(),
+                body: res.getJsonBody() ?? res.getSentBody(),
+                headers: res.getHeaders(),
+            };
+        },
+    };
+    return router;
+}
+//# sourceMappingURL=mock-router.js.map

package/dist/testing/mock-storage.d.ts

@@ -0,0 +1,9 @@
+import type { BlobStorage } from '../adapter/types';
+export interface MockStorage extends BlobStorage {
+    blobs: Map<string, {
+        data: Buffer;
+        contentType?: string;
+    }>;
+}
+export declare function createMockStorage(): MockStorage;
+//# sourceMappingURL=mock-storage.d.ts.map

package/dist/testing/mock-storage.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockStorage = createMockStorage;
+function createMockStorage() {
+    const blobs = new Map();
+    return {
+        blobs,
+        async put(key, data, contentType) {
+            blobs.set(key, { data, contentType });
+            return key;
+        },
+        async get(key) {
+            const entry = blobs.get(key);
+            return entry ? entry.data : undefined;
+        },
+        async delete(key) {
+            return blobs.delete(key);
+        },
+    };
+}
+//# sourceMappingURL=mock-storage.js.map

package/dist/testing/mock-store.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterStore } from '../adapter/types';
+export declare function createMockStore(instanceId: string): AdapterStore;
+//# sourceMappingURL=mock-store.d.ts.map

package/dist/testing/mock-store.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockStore = createMockStore;
+const scoped_store_1 = require("../adapter/scoped-store");
+function createMockStore(instanceId) {
+    return (0, scoped_store_1.createScopedAdapterStore)(instanceId);
+}
+//# sourceMappingURL=mock-store.js.map

package/dist/tools/delegate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * delegate_to_agent — 다른 에이전트에게 작업을 위임하는 빌트인 tool.
+ *
+ * PM → Dev처럼 에이전트 간 자동 위임을 가능하게 한다.
+ * crewx 인스턴스를 클로저로 캡처하여 내부에서 query/execute 호출.
+ */
+import type { ToolDefinition } from '../facade/Crewx';
+import type { Crewx } from '../facade/Crewx';
+export declare function createDelegateTool(crewx: Crewx): ToolDefinition;
+//# sourceMappingURL=delegate.d.ts.map

package/dist/tools/delegate.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * delegate_to_agent — 다른 에이전트에게 작업을 위임하는 빌트인 tool.
+ *
+ * PM → Dev처럼 에이전트 간 자동 위임을 가능하게 한다.
+ * crewx 인스턴스를 클로저로 캡처하여 내부에서 query/execute 호출.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDelegateTool = createDelegateTool;
+const MAX_DELEGATION_DEPTH = 3;
+let _delegationDepth = 0;
+function createDelegateTool(crewx) {
+    const agentIds = Array.from(crewx.agents.keys());
+    return {
+        name: 'delegate_to_agent',
+        description: `Delegate a task to another agent. Available agents: ${agentIds.join(', ')}`,
+        parameters: {
+            type: 'object',
+            properties: {
+                agent: {
+                    type: 'string',
+                    description: `Agent ID to delegate to. One of: ${agentIds.join(', ')}`,
+                },
+                message: {
+                    type: 'string',
+                    description: 'Task description for the target agent',
+                },
+                mode: {
+                    type: 'string',
+                    description: 'Execution mode: "query" for questions, "execute" for actions. Default: query',
+                },
+            },
+            required: ['agent', 'message'],
+        },
+        execute: async (args) => {
+            if (_delegationDepth >= MAX_DELEGATION_DEPTH) {
+                return `Error: Maximum delegation depth (${MAX_DELEGATION_DEPTH}) reached. Cannot delegate further.`;
+            }
+            const targetAgent = args.agent;
+            const taskMessage = args.message;
+            const mode = args.mode ?? 'query';
+            if (!agentIds.includes(targetAgent)) {
+                return `Error: Unknown agent "${targetAgent}". Available: ${agentIds.join(', ')}`;
+            }
+            _delegationDepth++;
+            try {
+                if (mode === 'execute') {
+                    const result = await crewx.execute(targetAgent, taskMessage);
+                    return result.ok ? result.data : `Error: ${result.error?.message ?? 'Unknown error'}`;
+                }
+                const result = await crewx.query(targetAgent, taskMessage);
+                return result.ok ? result.data : `Error: ${result.error?.message ?? 'Unknown error'}`;
+            }
+            finally {
+                _delegationDepth--;
+            }
+        },
+    };
+}
+//# sourceMappingURL=delegate.js.map

package/dist/tools/index.d.ts

@@ -1,12 +1,5 @@
-export { readFileTool } from './read-file.tool.js';
-export { replaceTool } from './replace.tool.js';
-export { runShellCommandTool } from './run-shell-command.tool.js';
-export { lsTool } from './ls.tool.js';
-export { treeTool } from './tree.tool.js';
-export { writeFileTool } from './write-file.tool.js';
-export { grepTool } from './grep.tool.js';
-export { findTool } from './find.tool.js';
-export { globTool } from './glob.tool.js';
-export { StandardFileSystemService } from './file-system.service.js';
-export * from './types.js';
-export * from './utils/file-utils.js';
+/**
+ * @crewx/sdk/tools — 빌트인 tool exports.
+ */
+export { createDelegateTool } from './delegate';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -1,40 +1,9 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
+/**
+ * @crewx/sdk/tools — 빌트인 tool exports.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StandardFileSystemService = exports.globTool = exports.findTool = exports.grepTool = exports.writeFileTool = exports.treeTool = exports.lsTool = exports.runShellCommandTool = exports.replaceTool = exports.readFileTool = void 0;
-var read_file_tool_js_1 = require("./read-file.tool.js");
-Object.defineProperty(exports, "readFileTool", { enumerable: true, get: function () { return read_file_tool_js_1.readFileTool; } });
-var replace_tool_js_1 = require("./replace.tool.js");
-Object.defineProperty(exports, "replaceTool", { enumerable: true, get: function () { return replace_tool_js_1.replaceTool; } });
-var run_shell_command_tool_js_1 = require("./run-shell-command.tool.js");
-Object.defineProperty(exports, "runShellCommandTool", { enumerable: true, get: function () { return run_shell_command_tool_js_1.runShellCommandTool; } });
-var ls_tool_js_1 = require("./ls.tool.js");
-Object.defineProperty(exports, "lsTool", { enumerable: true, get: function () { return ls_tool_js_1.lsTool; } });
-var tree_tool_js_1 = require("./tree.tool.js");
-Object.defineProperty(exports, "treeTool", { enumerable: true, get: function () { return tree_tool_js_1.treeTool; } });
-var write_file_tool_js_1 = require("./write-file.tool.js");
-Object.defineProperty(exports, "writeFileTool", { enumerable: true, get: function () { return write_file_tool_js_1.writeFileTool; } });
-var grep_tool_js_1 = require("./grep.tool.js");
-Object.defineProperty(exports, "grepTool", { enumerable: true, get: function () { return grep_tool_js_1.grepTool; } });
-var find_tool_js_1 = require("./find.tool.js");
-Object.defineProperty(exports, "findTool", { enumerable: true, get: function () { return find_tool_js_1.findTool; } });
-var glob_tool_js_1 = require("./glob.tool.js");
-Object.defineProperty(exports, "globTool", { enumerable: true, get: function () { return glob_tool_js_1.globTool; } });
-var file_system_service_js_1 = require("./file-system.service.js");
-Object.defineProperty(exports, "StandardFileSystemService", { enumerable: true, get: function () { return file_system_service_js_1.StandardFileSystemService; } });
-__exportStar(require("./types.js"), exports);
-__exportStar(require("./utils/file-utils.js"), exports);
+exports.createDelegateTool = void 0;
+var delegate_1 = require("./delegate");
+Object.defineProperty(exports, "createDelegateTool", { enumerable: true, get: function () { return delegate_1.createDelegateTool; } });
 //# sourceMappingURL=index.js.map