@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/tools/edit/core.js

@@ -0,0 +1,503 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { relative } from 'node:path';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { FileUndoManager } from '@pellux/goodvibes-sdk/platform/state/file-undo';
+import { FileStateCache, unifiedDiff } from '@pellux/goodvibes-sdk/platform/state/file-cache';
+import { resolveAndValidatePath } from '@pellux/goodvibes-sdk/platform/utils/path-safety';
+import { editSchema } from '@pellux/goodvibes-sdk/platform/tools/edit/schema';
+import { AutoHealer } from '../shared/auto-heal.js';
+import { ImportGraph } from '@pellux/goodvibes-sdk/platform/intelligence/index';
+import { buildFailedEditResult, classifyEditFailure, computeAstEdit, computeAstPatternEdit, computeSingleEdit, } from '@pellux/goodvibes-sdk/platform/tools/edit/match';
+import { executeNotebookEdit } from '@pellux/goodvibes-sdk/platform/tools/edit/notebook';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const DIFF_TRUNCATE_THRESHOLD = 5000;
+const DIFF_PREVIEW_LENGTH = 500;
+const VALIDATOR_COMMANDS = {
+    typecheck: ['npx', 'tsc', '--noEmit'],
+    lint: ['npx', 'eslint', '--no-error-on-unmatched-pattern'],
+    test: ['bun', 'test'],
+    build: ['bun', 'run', 'build'],
+};
+async function runValidator(name, cwd) {
+    const cmd = VALIDATOR_COMMANDS[name];
+    const TIMEOUT_MS = 30_000;
+    const proc = Bun.spawn(cmd, { cwd, stdout: 'pipe', stderr: 'pipe' });
+    let timedOut = false;
+    const timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        proc.kill();
+    }, TIMEOUT_MS);
+    const [exitCode, stdoutBuf, stderrBuf] = await Promise.all([
+        proc.exited,
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+    ]);
+    clearTimeout(timeoutHandle);
+    if (timedOut) {
+        return {
+            validator: name,
+            passed: false,
+            stdout: '',
+            stderr: `Validator '${name}' timed out after ${TIMEOUT_MS}ms`,
+            exitCode: -1,
+        };
+    }
+    return { validator: name, passed: exitCode === 0, stdout: stdoutBuf, stderr: stderrBuf, exitCode };
+}
+async function runValidators(validators, cwd) {
+    for (const name of validators) {
+        const result = await runValidator(name, cwd);
+        if (!result.passed)
+            return result;
+    }
+    return null;
+}
+function formatValidatorFailure(result) {
+    const parts = [`Validator '${result.validator}' failed (exit ${result.exitCode}):`];
+    if (result.stderr.trim())
+        parts.push(result.stderr.trim());
+    if (result.stdout.trim())
+        parts.push(result.stdout.trim());
+    return parts.join('\n');
+}
+function prepareTextEditInput(input, env, transactionMode) {
+    const resolvedPaths = new Map();
+    for (const item of input.edits) {
+        if (resolvedPaths.has(item.path))
+            continue;
+        try {
+            resolvedPaths.set(item.path, resolveAndValidatePath(item.path, env.cwd));
+        }
+        catch (err) {
+            const msg = summarizeError(err);
+            if (transactionMode === 'atomic') {
+                return { error: `Path error for '${item.path}': ${msg}` };
+            }
+        }
+    }
+    const uniquePaths = new Set(input.edits.map((e) => resolvedPaths.get(e.path) ?? e.path));
+    const fileContents = new Map();
+    const fileReadErrors = new Map();
+    for (const resolvedPath of uniquePaths) {
+        const cacheResult = env.fileCache.lookup(resolvedPath);
+        if (cacheResult.status === 'modified') {
+            const msg = `OCC conflict: '${resolvedPath}' was modified externally since last read`;
+            if (transactionMode === 'atomic') {
+                return { error: msg };
+            }
+            fileReadErrors.set(resolvedPath, msg);
+            continue;
+        }
+        try {
+            const content = readFileSync(resolvedPath, 'utf-8');
+            fileContents.set(resolvedPath, content);
+        }
+        catch {
+            const msg = `File not found or unreadable: '${resolvedPath}'`;
+            if (transactionMode === 'atomic') {
+                return { error: msg };
+            }
+            fileReadErrors.set(resolvedPath, msg);
+        }
+    }
+    return {
+        resolvedPaths,
+        fileContents,
+        fileReadErrors,
+        workingContents: new Map(fileContents),
+    };
+}
+function writeSuccessfulTextEdits(results, resolvedPaths, workingContents, fileContents, env, writtenPaths) {
+    for (const r of results) {
+        if (!r.success)
+            continue;
+        const resolvedPath = resolvedPaths.get(r.path);
+        if (!resolvedPath || writtenPaths.has(resolvedPath))
+            continue;
+        const newContent = workingContents.get(resolvedPath);
+        if (newContent === undefined)
+            continue;
+        try {
+            writeFileSync(resolvedPath, newContent, 'utf-8');
+            env.fileCache.update(resolvedPath, newContent);
+            writtenPaths.add(resolvedPath);
+            if (env.fileUndoManager) {
+                try {
+                    const originalContent = fileContents.get(resolvedPath) ?? null;
+                    env.fileUndoManager.snapshot({
+                        path: resolvedPath,
+                        beforeContent: originalContent,
+                        afterContent: newContent,
+                        tool: 'edit',
+                    });
+                }
+                catch {
+                    // Non-fatal
+                }
+            }
+            env.changeTracker?.recordChange(resolvedPath);
+        }
+        catch (err) {
+            const msg = `Write failed for '${resolvedPath}': ${summarizeError(err)}`;
+            for (const res of results) {
+                if (res.path === r.path) {
+                    res.success = false;
+                    res.error = msg;
+                }
+            }
+        }
+    }
+}
+async function buildImportGraphWarning(cwd, writtenPaths) {
+    try {
+        const graph = new ImportGraph();
+        graph.markDirty();
+        await graph.build(cwd);
+        const editedAbsPaths = [...writtenPaths];
+        const affectedSet = new Set();
+        for (const edited of editedAbsPaths) {
+            for (const dep of graph.findTransitiveDependents(edited)) {
+                affectedSet.add(dep);
+            }
+        }
+        for (const edited of editedAbsPaths) {
+            affectedSet.delete(edited);
+        }
+        if (affectedSet.size === 0)
+            return undefined;
+        const affectedList = Array.from(affectedSet);
+        const proc = Bun.spawn(['/bin/sh', '-c', `npx tsc --noEmit ${affectedList.join(' ')}`], {
+            cwd,
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        const [exitCode, stdoutText, stderrText] = await Promise.all([
+            proc.exited,
+            new Response(proc.stdout).text(),
+            new Response(proc.stderr).text(),
+        ]);
+        if (exitCode === 0)
+            return undefined;
+        const relAffected = affectedList.map((f) => relative(cwd, f));
+        const outputLines = (stderrText + '\n' + stdoutText)
+            .split('\n')
+            .filter((line) => relAffected.some((rel) => line.includes(rel)));
+        if (outputLines.length > 0) {
+            return `\n⚠ Import graph: ${affectedSet.size} transitive dependent(s) affected by this edit — type errors detected in downstream files:\n${outputLines.join('\n')}`;
+        }
+        return `\n⚠ Import graph: ${affectedSet.size} transitive dependent(s) affected. tsc reported errors outside the affected set — check unrelated files.`;
+    }
+    catch (err) {
+        logger.warn('[import-graph] Import graph tracing failed', { error: summarizeError(err) });
+        return undefined;
+    }
+}
+function restoreOriginalContents(fileContents, env) {
+    for (const [resolvedPath, originalContent] of fileContents) {
+        try {
+            writeFileSync(resolvedPath, originalContent, 'utf-8');
+            env.fileCache.update(resolvedPath, originalContent);
+        }
+        catch {
+            // Best-effort rollback
+        }
+    }
+}
+async function repairAfterValidationFailure(fileContents, workingContents, failureMessages, env) {
+    let healed = false;
+    for (const [resolvedPath, originalContent] of fileContents) {
+        const newContent = workingContents.get(resolvedPath);
+        if (newContent === undefined || newContent === originalContent)
+            continue;
+        const healResult = env.configManager && env.toolLLM
+            ? await new AutoHealer(env.configManager, env.toolLLM).heal(resolvedPath, newContent, failureMessages)
+            : { healed: false, content: newContent };
+        if (healResult.healed) {
+            try {
+                writeFileSync(resolvedPath, healResult.content, 'utf-8');
+                env.fileCache.update(resolvedPath, healResult.content);
+                healed = true;
+            }
+            catch {
+                // Best-effort heal write
+            }
+        }
+    }
+    return { healed };
+}
+async function validateAfterTextEdits(validators, cwd, transactionMode, fileContents, workingContents, env) {
+    const failure = await runValidators(validators, cwd);
+    if (!failure)
+        return {};
+    const failureMessages = [formatValidatorFailure(failure)];
+    const repair = await repairAfterValidationFailure(fileContents, workingContents, failureMessages, env);
+    if (repair.healed) {
+        const healFailure = await runValidators(validators, cwd);
+        if (!healFailure) {
+            return {};
+        }
+    }
+    if (transactionMode === 'atomic') {
+        restoreOriginalContents(fileContents, env);
+    }
+    return {
+        error: `Post-edit validation failed${transactionMode === 'atomic' ? ' — edits rolled back' : ''}. ${formatValidatorFailure(failure)}`,
+    };
+}
+function formatOutput(results, format, dryRun) {
+    const totalApplied = results.filter((r) => r.success).length;
+    const totalFailed = results.filter((r) => !r.success).length;
+    const dryTag = dryRun ? ' (dry run)' : '';
+    if (format === 'count_only') {
+        return JSON.stringify({ applied: totalApplied, failed: totalFailed, dry_run: dryRun });
+    }
+    const lines = [];
+    lines.push(`Edits applied: ${totalApplied}, failed: ${totalFailed}${dryTag}`);
+    if (format === 'minimal') {
+        for (const r of results) {
+            if (r.success) {
+                const id = r.id ? ` [${r.id}]` : '';
+                const statusTag = r.status ? ` [${r.status}]` : '';
+                lines.push(`  OK${statusTag}${id}: ${r.path} (${r.occurrencesReplaced} replacement(s))`);
+                if (r.warning) {
+                    lines.push(`    WARN: ${r.warning}`);
+                }
+            }
+            else {
+                const id = r.id ? ` [${r.id}]` : '';
+                const statusTag = r.status ? ` [${r.status}]` : '';
+                lines.push(`  FAIL${statusTag}${id}: ${r.path} — ${r.error}`);
+                if (r.hint) {
+                    lines.push(`    HINT: ${r.hint}`);
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    for (const r of results) {
+        const id = r.id ? ` [${r.id}]` : '';
+        if (r.success) {
+            const statusTag = r.status ? ` [${r.status}]` : '';
+            lines.push(`\n--- ${r.path}${id}${statusTag} (${r.occurrencesReplaced} replacement(s))${dryTag} ---`);
+            if (r.diff) {
+                if (r.diff_truncated) {
+                    lines.push(`[diff truncated — showing first ${DIFF_PREVIEW_LENGTH} chars]`);
+                    lines.push(r.diff_preview ?? r.diff.slice(0, DIFF_PREVIEW_LENGTH));
+                }
+                else {
+                    lines.push(r.diff);
+                }
+            }
+            if (r.warning) {
+                lines.push(`  WARN: ${r.warning}`);
+            }
+        }
+        else {
+            const statusTag = r.status ? ` [${r.status}]` : '';
+            lines.push(`\n--- ${r.path}${id}${statusTag} FAILED ---`);
+            lines.push(`  Error: ${r.error}`);
+            if (r.hint) {
+                lines.push(`  Hint: ${r.hint}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+async function executeTextEdits(input, env) {
+    const matchMode = input.match?.mode ?? 'exact';
+    const caseSensitive = input.match?.case_sensitive ?? true;
+    const whitespaceSensitive = input.match?.whitespace_sensitive ?? true;
+    const multiline = input.match?.multiline ?? false;
+    const transactionMode = input.transaction?.mode ?? 'atomic';
+    const outputFormat = input.output?.format ?? 'minimal';
+    const diffContext = input.output?.diff_context ?? 3;
+    const dryRun = input.dry_run ?? false;
+    const validateBefore = input.validate?.before ?? [];
+    const validateAfter = input.validate?.after ?? [];
+    const cwd = env.cwd;
+    if (!dryRun && validateBefore.length > 0) {
+        const failure = await runValidators(validateBefore, cwd);
+        if (failure) {
+            return { success: false, error: `Pre-edit validation failed. ${formatValidatorFailure(failure)}` };
+        }
+    }
+    const prepResult = prepareTextEditInput(input, env, transactionMode);
+    if ('error' in prepResult) {
+        return { success: false, error: prepResult.error };
+    }
+    const { resolvedPaths, fileContents, fileReadErrors, workingContents } = prepResult;
+    const results = [];
+    let atomicFailed = false;
+    let atomicFailError = '';
+    for (const item of input.edits) {
+        const resolvedPath = resolvedPaths.get(item.path);
+        if (!resolvedPath) {
+            results.push(buildFailedEditResult(item, `Path resolution failed for '${item.path}'`, 'failed'));
+            if (transactionMode === 'atomic') {
+                atomicFailed = true;
+                atomicFailError = `Path resolution failed for '${item.path}'`;
+                break;
+            }
+            continue;
+        }
+        if (fileReadErrors.has(resolvedPath)) {
+            const readErrMsg = fileReadErrors.get(resolvedPath);
+            results.push(buildFailedEditResult(item, readErrMsg, classifyEditFailure(readErrMsg)));
+            if (transactionMode === 'atomic') {
+                atomicFailed = true;
+                atomicFailError = readErrMsg;
+                break;
+            }
+            continue;
+        }
+        const currentContent = workingContents.get(resolvedPath);
+        if (currentContent === undefined) {
+            results.push(buildFailedEditResult(item, `No content available for '${resolvedPath}'`, 'failed'));
+            if (transactionMode === 'atomic') {
+                atomicFailed = true;
+                atomicFailError = `No content available for '${resolvedPath}'`;
+                break;
+            }
+            continue;
+        }
+        let editResult;
+        if (matchMode === 'ast_pattern') {
+            editResult = computeAstPatternEdit(currentContent, item, resolvedPath);
+        }
+        else if (matchMode === 'ast') {
+            editResult = await computeAstEdit(currentContent, item, resolvedPath);
+        }
+        else {
+            editResult = computeSingleEdit(currentContent, item, matchMode, caseSensitive, whitespaceSensitive, multiline);
+        }
+        if ('error' in editResult) {
+            const errMsg = editResult.error;
+            results.push({
+                ...buildFailedEditResult(item, errMsg, classifyEditFailure(errMsg)),
+                hint: 'hint' in editResult ? editResult.hint : undefined,
+            });
+            if (transactionMode === 'atomic') {
+                atomicFailed = true;
+                atomicFailError = errMsg;
+                break;
+            }
+            continue;
+        }
+        const oldContent = currentContent;
+        workingContents.set(resolvedPath, editResult.newContent);
+        let diff;
+        let diffTruncated;
+        let diffPreview;
+        if (outputFormat === 'with_diff' || outputFormat === 'verbose' || dryRun) {
+            const rawDiff = unifiedDiff(oldContent, editResult.newContent, resolvedPath, diffContext);
+            if (rawDiff.length > DIFF_TRUNCATE_THRESHOLD) {
+                diffTruncated = true;
+                diffPreview = rawDiff.slice(0, DIFF_PREVIEW_LENGTH);
+                diff = diffPreview;
+            }
+            else {
+                diff = rawDiff;
+            }
+        }
+        results.push({
+            id: item.id,
+            path: item.path,
+            success: true,
+            status: 'applied',
+            occurrencesReplaced: editResult.occurrencesReplaced,
+            diff,
+            diff_truncated: diffTruncated,
+            diff_preview: diffPreview,
+            warning: editResult.warning,
+        });
+    }
+    if (transactionMode === 'atomic' && atomicFailed) {
+        const atomicResults = input.edits.map((item, idx) => {
+            const r = results[idx];
+            if (r && !r.success)
+                return r;
+            return {
+                id: item.id,
+                path: item.path,
+                success: false,
+                status: 'failed',
+                error: r?.success ? 'Rolled back due to atomic transaction failure' : (r?.error ?? atomicFailError),
+            };
+        });
+        return {
+            success: false,
+            error: `Atomic transaction failed: ${atomicFailError}`,
+            output: formatOutput(atomicResults, outputFormat, dryRun),
+        };
+    }
+    const writtenPaths = new Set();
+    if (!dryRun) {
+        writeSuccessfulTextEdits(results, resolvedPaths, workingContents, fileContents, env, writtenPaths);
+    }
+    const anySuccess = results.some((r) => r.success);
+    let importGraphWarning;
+    if (!dryRun && anySuccess) {
+        importGraphWarning = await buildImportGraphWarning(cwd, writtenPaths);
+    }
+    if (!dryRun && anySuccess && validateAfter.length > 0) {
+        const validationResult = await validateAfterTextEdits(validateAfter, cwd, transactionMode, fileContents, workingContents, env);
+        if (validationResult.error) {
+            return { success: false, error: validationResult.error };
+        }
+    }
+    return {
+        success: anySuccess,
+        output: formatOutput(results, outputFormat, dryRun) + (importGraphWarning ?? ''),
+    };
+}
+function resolveEditCwd(options) {
+    if (options?.cwd && options.cwd.trim().length > 0) {
+        return options.cwd;
+    }
+    const workingDirectory = options?.configManager?.getWorkingDirectory();
+    if (workingDirectory && workingDirectory.trim().length > 0) {
+        return workingDirectory;
+    }
+    throw new Error('createEditTool requires an explicit cwd or configManager.getWorkingDirectory()');
+}
+export function createEditTool(fileCache, options) {
+    const cwd = resolveEditCwd(options);
+    const definition = {
+        name: 'edit',
+        description: 'Edit files by finding and replacing text. Supports exact, fuzzy, and regex matching. ' +
+            'Handles multiple edits in one call with atomic or partial transaction semantics. ' +
+            'Detects OCC conflicts when files have been modified externally. ' +
+            'Also supports Jupyter notebook (.ipynb) cell operations via notebook_operations field.',
+        parameters: editSchema,
+        sideEffects: ['write_fs'],
+        concurrency: 'serial',
+        supportsProgress: true,
+    };
+    async function execute(args) {
+        try {
+            const input = args;
+            if (!input.edits && !input.notebook_operations) {
+                return { success: false, error: 'Either edits or notebook_operations must be provided' };
+            }
+            if (input.edits && input.notebook_operations) {
+                return { success: false, error: 'Provide either edits or notebook_operations, not both' };
+            }
+            const env = {
+                fileCache,
+                cwd,
+                fileUndoManager: options?.fileUndoManager,
+                configManager: options?.configManager,
+                toolLLM: options?.toolLLM,
+                changeTracker: options?.changeTracker,
+            };
+            if (input.notebook_operations) {
+                return await executeNotebookEdit(input, env);
+            }
+            return await executeTextEdits(input, env);
+        }
+        catch (err) {
+            return { success: false, error: `Unexpected error: ${summarizeError(err)}` };
+        }
+    }
+    return { definition, execute };
+}

package/dist/_internal/platform/tools/edit/index.d.ts

@@ -0,0 +1,4 @@
+import { createEditTool } from './core.js';
+import type { EditToolOptions } from './core.js';
+export { createEditTool, type EditToolOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/edit/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/edit/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,EAAE,cAAc,EAAE,KAAK,eAAe,EAAE,CAAC"}

package/dist/_internal/platform/tools/edit/index.js

@@ -0,0 +1,2 @@
+import { createEditTool } from './core.js';
+export { createEditTool };

package/dist/_internal/platform/tools/edit/phased.d.ts

@@ -0,0 +1,15 @@
+import type { EditToolOptions } from './index.js';
+import type { FileStateCache } from '@pellux/goodvibes-sdk/platform/state/file-cache';
+/**
+ * Create a phased edit tool.
+ *
+ * Category  : `write` — edit operations mutate files on disk.
+ * Cancellable: `false` — mid-flight edits could corrupt open transactions;
+ *   the executor waits for completion before processing cancellation.
+ *
+ * @param fileCache - Shared FileStateCache instance for OCC conflict detection.
+ * @param options   - Optional edit tool configuration (cwd, fileUndoManager).
+ * @returns A PhasedTool that delegates execution to `createEditTool`.
+ */
+export declare function createPhasedEditTool(fileCache: FileStateCache, options?: EditToolOptions): import("@pellux/goodvibes-sdk/platform/runtime/tools/adapter").PhasedTool;
+//# sourceMappingURL=phased.d.ts.map

package/dist/_internal/platform/tools/edit/phased.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phased.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/edit/phased.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AAMtF;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,cAAc,EACzB,OAAO,CAAC,EAAE,eAAe,6EAI1B"}

package/dist/_internal/platform/tools/edit/phased.js

@@ -0,0 +1,26 @@
+/**
+ * Phased wrapper for the edit tool.
+ *
+ * Delegates entirely to the existing `createEditTool` implementation and adds
+ * the PhasedTool metadata required by the phased executor.
+ */
+import { asPhasedTool } from '@pellux/goodvibes-sdk/platform/runtime/tools/adapter';
+import { createEditTool } from './index.js';
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a phased edit tool.
+ *
+ * Category  : `write` — edit operations mutate files on disk.
+ * Cancellable: `false` — mid-flight edits could corrupt open transactions;
+ *   the executor waits for completion before processing cancellation.
+ *
+ * @param fileCache - Shared FileStateCache instance for OCC conflict detection.
+ * @param options   - Optional edit tool configuration (cwd, fileUndoManager).
+ * @returns A PhasedTool that delegates execution to `createEditTool`.
+ */
+export function createPhasedEditTool(fileCache, options) {
+    const inner = createEditTool(fileCache, options);
+    return asPhasedTool(inner, { category: 'write', cancellable: false });
+}

package/dist/_internal/platform/tools/fetch/index.d.ts

@@ -0,0 +1,4 @@
+export type { FetchUrlResult, FetchOutput } from '@pellux/goodvibes-sdk/platform/tools/fetch/types';
+export type { FetchRuntimeDeps } from './runtime.js';
+export { createFetchTool, executeFetchInput, FetchRuntimeService } from './runtime.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/fetch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/fetch/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,kDAAkD,CAAC;AACpG,YAAY,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC"}

package/dist/_internal/platform/tools/fetch/index.js

@@ -0,0 +1 @@
+export { createFetchTool, executeFetchInput, FetchRuntimeService } from './runtime.js';

package/dist/_internal/platform/tools/fetch/phased.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Create a phased fetch tool.
+ *
+ * Category      : `network` — routes to the network concurrency pool.
+ * Cancellable   : `true` — HTTP requests can be interrupted mid-flight by
+ *   closing the underlying socket; the executor passes an AbortSignal.
+ * phaseTimeouts : `{ executing: 30000 }` — overrides the default timeout for
+ *   the executing phase to allow for slow network responses.
+ *
+ * @returns A PhasedTool that delegates execution to an owned fetch tool instance.
+ */
+export declare function createPhasedFetchTool(): import("@pellux/goodvibes-sdk/platform/runtime/tools/adapter").PhasedTool;
+//# sourceMappingURL=phased.d.ts.map

package/dist/_internal/platform/tools/fetch/phased.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phased.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/fetch/phased.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,8EAEpC"}

package/dist/_internal/platform/tools/fetch/phased.js

@@ -0,0 +1,30 @@
+/**
+ * Phased wrapper for the fetch tool.
+ *
+ * Delegates to a freshly constructed fetch tool instance and adds the
+ * PhasedTool metadata required by the phased executor.
+ */
+import { asPhasedTool } from '@pellux/goodvibes-sdk/platform/runtime/tools/adapter';
+import { createFetchTool } from './index.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Default network timeout for the executing phase (30 seconds). */
+const NETWORK_EXECUTE_TIMEOUT_MS = 30_000;
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a phased fetch tool.
+ *
+ * Category      : `network` — routes to the network concurrency pool.
+ * Cancellable   : `true` — HTTP requests can be interrupted mid-flight by
+ *   closing the underlying socket; the executor passes an AbortSignal.
+ * phaseTimeouts : `{ executing: 30000 }` — overrides the default timeout for
+ *   the executing phase to allow for slow network responses.
+ *
+ * @returns A PhasedTool that delegates execution to an owned fetch tool instance.
+ */
+export function createPhasedFetchTool() {
+    return asPhasedTool(createFetchTool(), { category: 'network', cancellable: true, phaseTimeouts: { executing: NETWORK_EXECUTE_TIMEOUT_MS } });
+}

package/dist/_internal/platform/tools/fetch/runtime.d.ts

@@ -0,0 +1,25 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { FetchInput } from '@pellux/goodvibes-sdk/platform/tools/fetch/schema';
+import type { FetchOutput, FetchUrlResult } from '@pellux/goodvibes-sdk/platform/tools/fetch/types';
+import type { ServiceRegistry } from '../../config/service-registry.js';
+import type { FeatureFlagManager } from '@pellux/goodvibes-sdk/platform/runtime/feature-flags/index';
+export interface FetchRuntimeDeps {
+    readonly serviceRegistry?: Pick<ServiceRegistry, 'resolveAuth'> | null;
+    readonly featureFlags?: Pick<FeatureFlagManager, 'isEnabled'> | null;
+}
+interface CacheEntry {
+    data: FetchUrlResult;
+    timestamp: number;
+    ttl: number;
+}
+export declare class FetchRuntimeService {
+    private readonly responseCache;
+    private cacheWriteCount;
+    getCached(key: string, cacheTtlSeconds: number): FetchUrlResult | null;
+    cacheSet(key: string, entry: CacheEntry): void;
+    execute(input: FetchInput, deps?: FetchRuntimeDeps): Promise<FetchOutput>;
+}
+export declare function executeFetchInput(input: FetchInput, deps?: FetchRuntimeDeps): Promise<FetchOutput>;
+export declare function createFetchTool(deps?: FetchRuntimeDeps, runtime?: FetchRuntimeService): Tool;
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/_internal/platform/tools/fetch/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/fetch/runtime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,4CAA4C,CAAC;AAEvF,OAAO,KAAK,EAAE,UAAU,EAAsF,MAAM,mDAAmD,CAAC;AACxK,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,kDAAkD,CAAC;AACpG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAUxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4DAA4D,CAAC;AAGrG,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,eAAe,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,IAAI,CAAC;IACvE,QAAQ,CAAC,YAAY,CAAC,EAAE,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAAG,IAAI,CAAC;CACtE;AAED,UAAU,UAAU;IAClB,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb;AAMD,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiC;IAC/D,OAAO,CAAC,eAAe,CAAK;IAE5B,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAOtE,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI;IAiBxC,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,WAAW,CAAC;CA8DpF;AAED,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,WAAW,CAAC,CAE5G;AA+UD,wBAAgB,eAAe,CAC7B,IAAI,GAAE,gBAAqB,EAC3B,OAAO,sBAA4B,GAClC,IAAI,CAiCN"}